added ollama provider (compatible with anthropic)

Signed-off-by: Marek Safarik <msafarik@redhat.com>

Author: Marek Safarik

cmd/client/main.go

@@ -17,6 +17,7 @@ import (
 const (
 	defaultServerPath = "./server"
 	defaultPort       = "3000"
+	defaultOllamaURL  = "http://localhost:11434"
 	envFileLocation   = "./../.env"
 )
 
@@ -46,22 +47,20 @@ func main() {
 		port = defaultPort
 	}
 
-	apiKey := strings.TrimSpace(os.Getenv("ANTHROPIC_API_KEY"))
-	if apiKey == "" {
-		log.Println("ANTHROPIC_API_KEY environment variable not set")
-		return
-	}
-
 	if _, err := os.Stat(serverPath); os.IsNotExist(err) { // #nosec G703 -- serverPath from env/default, not user input
 		log.Printf("Warning: MCP server not found at %s", serverPath)
 		log.Printf("Build the server first: go build -o bin/server cmd/server/main.go")
 		return
 	}
 
-	provider := agent.NewClaudeProvider(apiKey)
-	agentInstance := agent.NewAgent(agent.Config{
-		ServerPath: serverPath,
-	}, provider)
+	provider, model := createProvider()
+
+	cfg := agent.Config{ServerPath: serverPath}
+	if model != "" {
+		cfg.Model = model
+	}
+
+	agentInstance := agent.NewAgent(cfg, provider)
 
 	if err := agentInstance.Connect(ctx); err != nil {
 		log.Printf("Failed to connect to MCP server: %v", err)
@@ -89,3 +88,27 @@ func main() {
 		return
 	}
 }
+
+// createProvider selects the LLM provider based on environment variables.
+// OLLAMA_URL or OLLAMA_MODEL → local Ollama (Anthropic-compatible API)
+// ANTHROPIC_API_KEY → Claude cloud API
+func createProvider() (agent.LLMProvider, string) {
+	ollamaURL := os.Getenv("OLLAMA_URL")
+	ollamaModel := os.Getenv("OLLAMA_MODEL")
+
+	if ollamaURL != "" || ollamaModel != "" {
+		if ollamaURL == "" {
+			ollamaURL = defaultOllamaURL
+		}
+		log.Printf("Using Ollama provider at %s", ollamaURL)
+		return agent.NewOllamaProvider(ollamaURL), ollamaModel
+	}
+
+	apiKey := strings.TrimSpace(os.Getenv("ANTHROPIC_API_KEY"))
+	if apiKey == "" {
+		log.Fatal("Set ANTHROPIC_API_KEY for Claude or OLLAMA_URL/OLLAMA_MODEL for local Ollama")
+	}
+
+	log.Printf("Using Claude provider")
+	return agent.NewClaudeProvider(apiKey), ""
+}

internal/agent/provider_claude.go internal/agent/provider_anthropic.gointernal/agent/provider_claude.go renamed to internal/agent/provider_anthropic.go

@@ -9,19 +9,28 @@ import (
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
-type ClaudeProvider struct {
+type AnthropicProvider struct {
 	client anthropic.Client
 }
 
-func NewClaudeProvider(apiKey string) *ClaudeProvider {
-	return &ClaudeProvider{
+func NewClaudeProvider(apiKey string) *AnthropicProvider {
+	return &AnthropicProvider{
 		client: anthropic.NewClient(option.WithAPIKey(apiKey)),
 	}
 }
 
-func (p *ClaudeProvider) Chat(ctx context.Context, opts ChatOptions) (*LLMResponse, error) {
-	messages := convertMessagesToClaude(opts.Messages)
-	tools := convertToolsToClaude(opts.Tools)
+func NewOllamaProvider(baseURL string) *AnthropicProvider {
+	return &AnthropicProvider{
+		client: anthropic.NewClient(
+			option.WithBaseURL(baseURL),
+			option.WithAPIKey("ollama"),
+		),
+	}
+}
+
+func (p *AnthropicProvider) Chat(ctx context.Context, opts ChatOptions) (*LLMResponse, error) {
+	messages := convertMessagesToAnthropic(opts.Messages)
+	tools := convertToolsToAnthropic(opts.Tools)
 
 	response, err := p.client.Messages.New(ctx, anthropic.MessageNewParams{
 		Model:     anthropic.Model(opts.Model),
@@ -31,13 +40,13 @@ func (p *ClaudeProvider) Chat(ctx context.Context, opts ChatOptions) (*LLMRespon
 		Tools:     tools,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("claude API error: %w", err)
+		return nil, fmt.Errorf("LLM API error: %w", err)
 	}
 
-	return parseClaudeResponse(response), nil
+	return parseAnthropicResponse(response), nil
 }
 
-func convertMessagesToClaude(messages []Message) []anthropic.MessageParam {
+func convertMessagesToAnthropic(messages []Message) []anthropic.MessageParam {
 	result := make([]anthropic.MessageParam, 0, len(messages))
 
 	i := 0
@@ -77,15 +86,15 @@ func convertMessagesToClaude(messages []Message) []anthropic.MessageParam {
 	return result
 }
 
-func convertToolsToClaude(tools []*mcp.Tool) []anthropic.ToolUnionParam {
+func convertToolsToAnthropic(tools []*mcp.Tool) []anthropic.ToolUnionParam {
 	result := make([]anthropic.ToolUnionParam, 0, len(tools))
 	for _, tool := range tools {
-		result = append(result, convertMCPToolToClaude(tool))
+		result = append(result, convertMCPToolToAnthropic(tool))
 	}
 	return result
 }
 
-func convertMCPToolToClaude(tool *mcp.Tool) anthropic.ToolUnionParam {
+func convertMCPToolToAnthropic(tool *mcp.Tool) anthropic.ToolUnionParam {
 	inputSchemaMap, ok := tool.InputSchema.(map[string]any)
 	if !ok || inputSchemaMap == nil {
 		inputSchemaMap = map[string]any{}
@@ -120,7 +129,7 @@ func convertMCPToolToClaude(tool *mcp.Tool) anthropic.ToolUnionParam {
 	return toolParam
 }
 
-func parseClaudeResponse(response *anthropic.Message) *LLMResponse {
+func parseAnthropicResponse(response *anthropic.Message) *LLMResponse {
 	result := &LLMResponse{}
 
 	for _, block := range response.Content {