done

Author: Gekko0114

examples/agent/main.go

@@ -16,10 +16,10 @@ func main() {
 	if err != nil {
 		fmt.Println(err)
 	}
-	prompt := "青を英語で言うと、何か？"
+	prompt := "日本の首相の名前は？"
 	result, err := agentExecutor.Invoke(prompt)
 	if err != nil {
 		fmt.Println(err)
 	}
-	fmt.Printf("Response: %+v\n", result)
+	fmt.Printf("%+v\n", result)
 }

pkg/agent/agent.go

@@ -55,7 +55,7 @@ func CreatePrompt(tools map[string]Tool) (*prompt.ChatPromptTemplate, error) {
 	return prompt, nil
 }
 
-func (a *Agent) Plan(intermediateSteps []string) (*NextAction, error) {
+func (a *Agent) Plan(intermediateSteps []string) (*NextAction, string, error) {
 	var nextaction *NextAction
 	agentScratchpad := strings.Join(intermediateSteps, "\n")
 	m := map[string]string{
@@ -65,14 +65,18 @@ func (a *Agent) Plan(intermediateSteps []string) (*NextAction, error) {
 
 	agentDecision, err := a.LLMChain.Invoke(m)
 	if err != nil {
-		return nil, err
+		return nil, "", err
+	}
+	decision := agentDecision.(string)
+
+	err = json.Unmarshal([]byte(decision), &nextaction)
+	if strings.HasPrefix(decision, "FinalAnswer") {
+		return nil, decision, nil
 	}
-	fmt.Printf("agentDecision: %v\n", agentDecision)
-	err = json.Unmarshal([]byte(agentDecision.(string)), &nextaction)
 	if err != nil {
-		return nil, fmt.Errorf("got an error during Plan: %w", err)
+		return nil, "", fmt.Errorf("got an error during Plan: %w", err)
 	}
-	return nextaction, err
+	return nextaction, "", err
 }
 
 type NextAction struct {

pkg/agent/agent_executor.go

@@ -26,48 +26,51 @@ func InitializeAgent(tools map[string]Tool, llm lib.Runnable) (*AgentExecutor, e
 }
 
 func (a *AgentExecutor) Invoke(input any) (any, error) {
-	switch input.(type) {
-	case string:
-		a.Agent.UserInput = input.(string)
-	default:
-		return nil, nil
-	}
+	a.Agent.UserInput = input.(string)
 	output, err := a.call()
 	if err != nil {
 		return nil, err
 	}
 	return output, nil
 }
 
-func (a *AgentExecutor) takeNextStep(intermediateSteps []string) (any, error) {
-	var observation any
-	output, err := a.Agent.Plan(intermediateSteps)
+func (a *AgentExecutor) takeNextStep(intermediateSteps []string) (string, string, error) {
+	var observation string
+	nextaction, finalanswer, err := a.Agent.Plan(intermediateSteps)
 	if err != nil {
-		return nil, err
+		return "", "", err
 	}
-	if tool, ok := a.Tools[output.Action.Action_name]; ok {
-		observation, err = tool.run(output.Action.Action_input)
+	if len(finalanswer) > 1 {
+		return "", finalanswer, nil
+	}
+	if tool, ok := a.Tools[nextaction.Action.Action_name]; ok {
+		observation, err = tool.run(nextaction.Action.Action_input)
 		if err != nil {
-			return nil, fmt.Errorf("error during takeNextStep: %w", err)
+			return "", "", fmt.Errorf("error during takeNextStep: %w", err)
 		}
 	}
+	nextactionstring := fmt.Sprintf("Thought: %s\nAction_name: %s\nAction_input: %s", nextaction.Thought, nextaction.Action.Action_name, nextaction.Action.Action_input)
 
-	return observation, nil
+	return observation, nextactionstring, nil
 }
 
 func (a *AgentExecutor) call() (any, error) {
 	iterations := 0
 	var nextStepOutput any
 	var intermediateSteps []string
 	for a.MaxIterations > iterations {
-		nextStepOutput, err := a.takeNextStep(intermediateSteps)
+		nextStepOutput, pastaction, err := a.takeNextStep(intermediateSteps)
 		if err != nil {
 			return nil, err
 		}
+		if nextStepOutput == "" {
+			return pastaction, nil
+		}
 		jsonData, err := json.Marshal(nextStepOutput)
 		if err != nil {
 			return nil, err
 		}
+		intermediateSteps = append(intermediateSteps, pastaction)
 		intermediateSteps = append(intermediateSteps, string(jsonData))
 		iterations += 1
 	}

pkg/agent/prompt.go

@@ -26,6 +26,6 @@ ALWAYS use the following format:
 Observation: the result of the action
 ... (this Thought/Action/Observation can repeat N times)
 Thought: I now know the final answer
-Final Answer: the final answer to the original input question`
-const SYSTEM_MESSAGE_SUFFIX = "Begin! Reminder to always use the exact characters `Final Answer` when responding."
+FinalAnswer: the final answer to the original input question`
+const SYSTEM_MESSAGE_SUFFIX = "Begin! Reminder to always use the exact characters `FinalAnswer` when responding."
 const HUMAN_MESSAGE = "{{ .Input }}\n\n{{ .Agent_scratchpad }}"

pkg/agent/tool.go

@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"strings"
 )
 
 var AvailableTools = map[string]Tool{
@@ -15,7 +16,7 @@ var AvailableTools = map[string]Tool{
 type Tool interface {
 	name() string
 	description() string
-	run(input any) (any, error)
+	run(input any) (string, error)
 }
 
 func LoadTools(tools []string) map[string]Tool {
@@ -30,8 +31,11 @@ func LoadTools(tools []string) map[string]Tool {
 }
 
 type OrganicResult struct {
-	Title string `json:"title"`
-	Link  string `json:"link"`
+	Title                   string   `json:"title"`
+	Link                    string   `json:"link"`
+	Snippet                 string   `json:"snippet"`
+	SnippetHighlightedWords []string `json:"snippet_highlighted_words"`
+	RichSnippet             string   `json:"rich_snippet"`
 }
 
 type SerpApiResponse struct {
@@ -49,7 +53,7 @@ func (s *SerpAPI) description() string {
 	return "A search engine. Useful for when you need to answer questions about current events. Input should be a search query."
 }
 
-func (s *SerpAPI) run(input any) (any, error) {
+func (s *SerpAPI) run(input any) (string, error) {
 	apiKey := os.Getenv("SERPAPI_API_KEY")
 	searchQuery := input.(string)
 	serpApiURL := "https://serpapi.com/search"
@@ -61,17 +65,28 @@ func (s *SerpAPI) run(input any) (any, error) {
 
 	resp, err := http.Get(fmt.Sprintf("%s?%s", serpApiURL, params.Encode()))
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return nil, err
+		return "", err
 	}
 
 	var response SerpApiResponse
 	if err := json.Unmarshal(body, &response); err != nil {
-		return nil, err
+		return "", err
 	}
-	fmt.Printf("serpapi run: %+v\n", response)
-	return response, nil
+	snippets := []string{}
+	for _, result := range response.OrganicResults {
+		if len(result.Snippet) > 0 {
+			snippets = append(snippets, result.Snippet)
+		}
+		if len(result.SnippetHighlightedWords) > 0 {
+			snippets = append(snippets, strings.Join(result.SnippetHighlightedWords, "\n"))
+		}
+		if len(result.RichSnippet) > 0 {
+			snippets = append(snippets, result.RichSnippet)
+		}
+	}
+	return strings.Join(snippets, "\n"), nil
 }