Web GUI (slow without streaming)

Signed-off-by: Marek Safarik <[email protected]>

Author: Marek Safarik

Makefile

@@ -44,3 +44,6 @@ clean:
 
 mcp:
 	cd backend && go build -o server *.go
+
+web:
+	cd mcp-client && go run *.go --web

mcp-client/agent.go

@@ -0,0 +1,306 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"os/exec"
+	"strings"
+
+	"github.com/anthropics/anthropic-sdk-go"
+	"github.com/anthropics/anthropic-sdk-go/option"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+var (
+	ErrMissingAPIKey = errors.New("ANTHROPIC_API_KEY environment variable not set")
+	ErrServerNotFound = errors.New("MCP server binary not found")
+)
+
+type OutputHandler func(message string)
+
+type Agent struct {
+	config          *Config
+	session         *mcp.ClientSession
+	cmd             *exec.Cmd
+	anthropicClient anthropic.Client
+	claudeTools     []anthropic.ToolUnionParam
+	outputHandler   OutputHandler
+}
+
+func NewAgent(cfg *Config) *Agent {
+	return &Agent{
+		config:        cfg,
+		outputHandler: defaultOutputHandler,
+	}
+}
+
+func (a *Agent) SetOutputHandler(handler OutputHandler) {
+	a.outputHandler = handler
+}
+
+func (a *Agent) output(message string) {
+	if a.outputHandler != nil {
+		a.outputHandler(message)
+	}
+}
+
+func defaultOutputHandler(message string) {
+	fmt.Println(message)
+}
+
+func (a *Agent) Initialize(ctx context.Context) error {
+	if err := a.connectToMCPServer(ctx); err != nil {
+		return fmt.Errorf("failed to connect to MCP server: %w", err)
+	}
+
+	if err := a.loadMCPTools(ctx); err != nil {
+		return fmt.Errorf("failed to load MCP tools: %w", err)
+	}
+
+	a.anthropicClient = anthropic.NewClient(option.WithAPIKey(a.config.AnthropicAPIKey))
+
+	return nil
+}
+
+func (a *Agent) Close() {
+	if a.session != nil {
+		a.session.Close()
+	}
+	if a.cmd != nil && a.cmd.Process != nil {
+		a.cmd.Process.Kill()
+	}
+}
+
+func (a *Agent) connectToMCPServer(ctx context.Context) error {
+	client := mcp.NewClient(&mcp.Implementation{
+		Name:    mcpClientName,
+		Version: mcpClientVersion,
+	}, nil)
+
+	cmd := exec.Command(a.config.MCPServerPath)
+	transport := &mcp.CommandTransport{Command: cmd}
+	session, err := client.Connect(ctx, transport, nil)
+	if err != nil {
+		return fmt.Errorf("failed to connect: %w", err)
+	}
+
+	a.session = session
+	a.cmd = cmd
+
+	a.monitorServerProcess(ctx)
+
+	log.Printf("Connected to MCP server: %s", a.config.MCPServerPath)
+	return nil
+}
+
+func (a *Agent) monitorServerProcess(ctx context.Context) {
+	if a.cmd.Process != nil {
+		go func() {
+			state, waitErr := a.cmd.Process.Wait()
+			if ctx.Err() != nil {
+				return
+			}
+			if waitErr != nil {
+				log.Printf("[Warning] MCP server process monitoring failed: %v", waitErr)
+			} else if !state.Success() {
+				log.Printf("[Error] MCP server process exited unexpectedly with status: %v", state)
+			} else {
+				log.Printf("[Info] MCP server process exited normally")
+			}
+		}()
+	}
+}
+
+func (a *Agent) loadMCPTools(ctx context.Context) error {
+	tools, err := a.session.ListTools(ctx, &mcp.ListToolsParams{})
+	if err != nil {
+		return fmt.Errorf("failed to list tools: %w", err)
+	}
+
+	a.claudeTools = make([]anthropic.ToolUnionParam, 0, len(tools.Tools))
+	for _, tool := range tools.Tools {
+		claudeTool := a.convertMCPToolToClaudeTool(tool)
+		a.claudeTools = append(a.claudeTools, claudeTool)
+	}
+
+	return nil
+}
+
+func (a *Agent) convertMCPToolToClaudeTool(tool *mcp.Tool) anthropic.ToolUnionParam {
+	inputSchemaMap, ok := tool.InputSchema.(map[string]any)
+	if !ok || inputSchemaMap == nil {
+		inputSchemaMap = map[string]any{}
+	}
+
+	var properties any
+	if p, ok := inputSchemaMap["properties"].(map[string]any); ok && p != nil {
+		properties = p
+	} else {
+		properties = map[string]any{}
+	}
+
+	var required []string
+	if r, ok := inputSchemaMap["required"].([]interface{}); ok {
+		for _, v := range r {
+			if s, ok := v.(string); ok {
+				required = append(required, s)
+			}
+		}
+	}
+
+	toolParam := anthropic.ToolUnionParamOfTool(
+		anthropic.ToolInputSchemaParam{
+			Type:       "object",
+			Properties: properties,
+			Required:   required,
+		},
+		tool.Name,
+	)
+
+	toolParam.OfTool.Description = anthropic.String(tool.Description)
+	return toolParam
+}
+
+func (a *Agent) ProcessQuery(ctx context.Context, query string) error {
+	messages := []anthropic.MessageParam{
+		anthropic.NewUserMessage(anthropic.NewTextBlock(query)),
+	}
+
+	for _ = range maxAgentTurns {
+		message, err := a.anthropicClient.Messages.New(ctx, anthropic.MessageNewParams{
+			Model:     claudeModel,
+			MaxTokens: maxTokens,
+			System:    []anthropic.TextBlockParam{{Type: "text", Text: systemPrompt}},
+			Messages:  messages,
+			Tools:     a.claudeTools,
+		})
+		if err != nil {
+			return fmt.Errorf("claude API error: %w", err)
+		}
+
+		assistantContent, toolResults, hasToolUse := a.processClaudeResponse(ctx, message)
+
+		if !hasToolUse {
+			return nil
+		}
+
+		messages = append(messages, anthropic.NewAssistantMessage(assistantContent...))
+		messages = append(messages, anthropic.NewUserMessage(toolResults...))
+	}
+
+	a.output("\n=== Maximum turns reached, requesting summary ===")
+	a.generateFinalSummary(ctx, messages)
+
+	return nil
+}
+
+func (a *Agent) processClaudeResponse(
+	ctx context.Context,
+	message *anthropic.Message,
+) (
+	assistantContent []anthropic.ContentBlockParamUnion,
+	toolResults []anthropic.ContentBlockParamUnion,
+	hasToolUse bool,
+) {
+	assistantContent = []anthropic.ContentBlockParamUnion{}
+	toolResults = []anthropic.ContentBlockParamUnion{}
+
+	for _, block := range message.Content {
+		switch block := block.AsAny().(type) {
+		case anthropic.TextBlock:
+			a.output(block.Text)
+			assistantContent = append(assistantContent, anthropic.NewTextBlock(block.Text))
+
+		case anthropic.ToolUseBlock:
+			hasToolUse = true
+			log.Printf("\n[Tool Use] %s", block.Name)
+
+			assistantContent = append(assistantContent,
+				anthropic.NewToolUseBlock(block.ID, block.Input, block.Name))
+
+			toolResult := a.executeToolCall(ctx, block)
+			toolResults = append(toolResults, toolResult)
+		}
+	}
+
+	return assistantContent, toolResults, hasToolUse
+}
+
+func (a *Agent) executeToolCall(
+	ctx context.Context,
+	toolUse anthropic.ToolUseBlock,
+) anthropic.ContentBlockParamUnion {
+	result, err := a.session.CallTool(ctx, &mcp.CallToolParams{
+		Name:      toolUse.Name,
+		Arguments: toolUse.Input,
+	})
+
+	if err != nil {
+		log.Printf("[Error] CallTool failed: %v", err)
+		return anthropic.NewToolResultBlock(
+			toolUse.ID,
+			fmt.Sprintf("Error: %v", err),
+			true,
+		)
+	}
+
+	if result.IsError {
+		errorDetails := extractTextContent(result.Content)
+		log.Printf("[Error] Tool execution failed for tool '%s': %s", toolUse.Name, errorDetails)
+		return anthropic.NewToolResultBlock(
+			toolUse.ID,
+			fmt.Sprintf("Tool '%s' execution failed: %s", toolUse.Name, errorDetails),
+			true,
+		)
+	}
+
+	resultText := extractTextContent(result.Content)
+	if resultText == "" {
+		log.Printf("[Warning] Tool returned empty content - this might indicate an unexpected response from MCP server")
+	}
+	log.Printf("================================================")
+	log.Printf("[Tool Result]\n%s", resultText)
+	log.Printf("================================================")
+
+	return anthropic.NewToolResultBlock(toolUse.ID, resultText, false)
+}
+
+func (a *Agent) generateFinalSummary(ctx context.Context, messages []anthropic.MessageParam) {
+	summaryPrompt := `I've reached the maximum number of allowed turns. Please provide a summary of:
+1. What you accomplished so far
+2. What still needs to be done
+3. Any issues or blockers encountered`
+
+	messages = append(messages, anthropic.NewUserMessage(anthropic.NewTextBlock(summaryPrompt)))
+
+	finalMsg, err := a.anthropicClient.Messages.New(ctx, anthropic.MessageNewParams{
+		Model:     claudeModel,
+		MaxTokens: maxTokens,
+		System:    []anthropic.TextBlockParam{{Type: "text", Text: systemPrompt}},
+		Messages:  messages,
+	})
+	if err != nil {
+		log.Printf("failed to get final summary: %v", err)
+		return
+	}
+
+	for _, block := range finalMsg.Content {
+		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
+			a.output(textBlock.Text)
+		}
+	}
+}
+
+func extractTextContent(content []mcp.Content) string {
+	var resultText strings.Builder
+
+	for _, c := range content {
+		if textContent, ok := c.(*mcp.TextContent); ok {
+			resultText.WriteString(textContent.Text)
+		}
+	}
+
+	return resultText.String()
+}

mcp-client/config.go

@@ -0,0 +1,42 @@
+package main
+
+import "github.com/anthropics/anthropic-sdk-go"
+
+const (
+	defaultServerPath = "../backend/server"
+	mcpClientName     = "mcp-client"
+	mcpClientVersion  = "v1.0.0"
+
+	claudeModel   = anthropic.ModelClaude3_5HaikuLatest
+	maxTokens     = 2048
+	maxAgentTurns = 5
+
+	systemPrompt = `You are an AI assistant with access to Keylime system management tools. Your goal is to help users manage and monitor their Keylime infrastructure.
+
+You have a maximum of 5 conversation turns to complete the task. When given a task:
+1. Break it down into steps if needed
+2. Use available tools to gather information and take actions
+3. Chain multiple tool calls together to accomplish complex tasks
+4. Provide clear explanations of what you're doing and what you found
+5. If you encounter failures, investigate and suggest solutions
+6. Work efficiently to complete tasks within the turn limit`
+)
+
+type Config struct {
+	AnthropicAPIKey string
+	MCPServerPath   string
+}
+
+func NewConfig() (*Config, error) {
+	apiKey := getEnvOrDefault("ANTHROPIC_API_KEY", "")
+	if apiKey == "" {
+		return nil, ErrMissingAPIKey
+	}
+
+	serverPath := getEnvOrDefault("MCP_SERVER_PATH", defaultServerPath)
+
+	return &Config{
+		AnthropicAPIKey: apiKey,
+		MCPServerPath:   serverPath,
+	}, nil
+}

mcp-client/go.mod

@@ -9,6 +9,7 @@ require (
 )
 
 require (
+	github.com/go-chi/chi/v5 v5.2.3 // indirect
 	github.com/google/jsonschema-go v0.3.0 // indirect
 	github.com/tidwall/gjson v1.18.0 // indirect
 	github.com/tidwall/match v1.1.1 // indirect

mcp-client/go.sum

@@ -2,6 +2,8 @@ github.com/anthropics/anthropic-sdk-go v1.18.0 h1:jfxRA7AqZoCm83nHO/OVQp8xuwjUKt
 github.com/anthropics/anthropic-sdk-go v1.18.0/go.mod h1:WTz31rIUHUHqai2UslPpw5CwXrQP3geYBioRV4WOLvE=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/go-chi/chi/v5 v5.2.3 h1:WQIt9uxdsAbgIYgid+BpYc+liqQZGMHRaUwp0JUcvdE=
+github.com/go-chi/chi/v5 v5.2.3/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/jsonschema-go v0.3.0 h1:6AH2TxVNtk3IlvkkhjrtbUc4S8AvO0Xii0DxIygDg+Q=