add and implement anthropic and gemini api services

Author: Jawher Kallel

gateway/internal/config/config.go

@@ -14,6 +14,8 @@ type Config struct {
     GroqKey        string
     RedisAddr  string
 	OpenRouterKey string
+	AnthropicKey string
+	GeminiKey string
 }
 
 func Load() *Config {
@@ -28,6 +30,8 @@ func Load() *Config {
 		HuggingFaceKey: getEnv("HF_API_KEY", ""),
 		GroqKey:       getEnv("GROQ_API_KEY", ""),
 		OpenRouterKey: getEnv("OPENROUTER_API_KEY", ""),
+		AnthropicKey: getEnv("ANTHROPIC_API_KEY", ""),
+		GeminiKey: getEnv("GEMINI_API_KEY", ""),
 		RedisAddr:      getEnv("REDIS_ADDR", "localhost:6379"),
 	}
 	if cfg.OpenAIKey == "" {

gateway/internal/handlers/query.go

@@ -48,6 +48,10 @@ func QueryHandler(cfg *config.Config, cache *cache.Cache) gin.HandlerFunc {
             response, err = services.QueryGroq(cfg.GroqKey, req.Prompt)
         case "openrouter":
             response, err = services.QueryOpenRouter(cfg.OpenRouterKey, req.Prompt)
+        case "anthropic":
+            response, err = services.QueryAnthropic(cfg.AnthropicKey, req.Prompt)
+        case "gemini":
+            response, err = services.QueryGemini(cfg.GeminiKey, req.Prompt)
         default:
             c.JSON(http.StatusBadRequest, gin.H{"error": "Unsupported provider"})
             return

gateway/internal/services/anthropic.go

@@ -0,0 +1,78 @@
+package services
+
+import (
+    "bytes"
+    "encoding/json"
+    "fmt"
+    "io"
+    "net/http"
+)
+
+type AnthropicMessage struct {
+    Role    string `json:"role"`
+    Content string `json:"content"`
+}
+
+type AnthropicRequest struct {
+    Model     string            `json:"model"`
+    MaxTokens int               `json:"max_tokens"`
+    Messages  []AnthropicMessage `json:"messages"`
+}
+
+type AnthropicResponse struct {
+    Content string `json:"content"`
+    Error   struct {
+        Message string `json:"message"`
+    } `json:"error"`
+}
+
+func QueryAnthropic(apiKey, prompt string) (string, error) {
+    reqBody := AnthropicRequest{
+        Model:     "claude-sonnet-4-20250514",
+        MaxTokens: 1000,
+        Messages: []AnthropicMessage{
+            {Role: "user", Content: prompt},
+        },
+    }
+    jsonData, _ := json.Marshal(reqBody)
+
+    req, _ := http.NewRequest("POST", "https://api.anthropic.com/v1/messages", bytes.NewBuffer(jsonData))
+    req.Header.Set("x-api-key", apiKey)
+    req.Header.Set("Content-Type", "application/json")
+    req.Header.Set("anthropic-version", "2023-06-01")
+
+    client := &http.Client{}
+    resp, err := client.Do(req)
+    if err != nil {
+        return "", err
+    }
+    defer resp.Body.Close()
+
+    bodyBytes, _ := io.ReadAll(resp.Body)
+    if resp.StatusCode != http.StatusOK {
+        var errResp AnthropicResponse
+        json.Unmarshal(bodyBytes, &errResp)
+        if errResp.Error.Message != "" {
+            return "", fmt.Errorf("Anthropic error: %s", errResp.Error.Message)
+        }
+        return "", fmt.Errorf("Anthropic API error: %s", string(bodyBytes))
+    }
+
+    // Adjust Anthropic's response as needed
+    var result map[string]interface{}
+    if err := json.Unmarshal(bodyBytes, &result); err != nil {
+        return "", fmt.Errorf("failed to parse Anthropic response: %w", err)
+    }
+    // Extract the content from the first message
+    if messages, ok := result["content"].(string); ok && messages != "" {
+        return messages, nil
+    }
+    if messages, ok := result["content"].([]interface{}); ok && len(messages) > 0 {
+        if msg, ok := messages[0].(map[string]interface{}); ok {
+            if content, ok := msg["text"].(string); ok {
+                return content, nil
+            }
+        }
+    }
+    return "", fmt.Errorf("no content returned from Anthropic: %s", string(bodyBytes))
+}

gateway/internal/services/gemini.go

@@ -0,0 +1,79 @@
+package services
+
+import (
+    "bytes"
+    "encoding/json"
+    "fmt"
+    "io"
+    "net/http"
+)
+
+type GeminiPart struct {
+    Text string `json:"text"`
+}
+
+type GeminiContent struct {
+    Parts []GeminiPart `json:"parts"`
+}
+
+type GeminiRequest struct {
+    Contents []GeminiContent `json:"contents"`
+}
+
+type GeminiResponse struct {
+    Candidates []struct {
+        Content struct {
+            Parts []struct {
+                Text string `json:"text"`
+            } `json:"parts"`
+        } `json:"content"`
+    } `json:"candidates"`
+    Error struct {
+        Message string `json:"message"`
+    } `json:"error"`
+}
+
+func QueryGemini(apiKey, prompt string) (string, error) {
+    reqBody := GeminiRequest{
+        Contents: []GeminiContent{
+            {
+                Parts: []GeminiPart{
+                    {Text: prompt},
+                },
+            },
+        },
+    }
+    jsonData, _ := json.Marshal(reqBody)
+
+    url := "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
+    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+    req.Header.Set("Content-Type", "application/json")
+    req.Header.Set("X-goog-api-key", apiKey)
+
+    client := &http.Client{}
+    resp, err := client.Do(req)
+    if err != nil {
+        return "", err
+    }
+    defer resp.Body.Close()
+
+    bodyBytes, _ := io.ReadAll(resp.Body)
+    if resp.StatusCode != http.StatusOK {
+        var errResp GeminiResponse
+        json.Unmarshal(bodyBytes, &errResp)
+        if errResp.Error.Message != "" {
+            return "", fmt.Errorf("Gemini error: %s", errResp.Error.Message)
+        }
+        return "", fmt.Errorf("Gemini API error: %s", string(bodyBytes))
+    }
+
+    var result GeminiResponse
+    if err := json.Unmarshal(bodyBytes, &result); err != nil {
+        return "", fmt.Errorf("failed to parse Gemini response: %w", err)
+    }
+
+    if len(result.Candidates) > 0 && len(result.Candidates[0].Content.Parts) > 0 {
+        return result.Candidates[0].Content.Parts[0].Text, nil
+    }
+    return "", fmt.Errorf("no candidates returned from Gemini: %s", string(bodyBytes))
+}

infra/docker-compose.yml

@@ -26,8 +26,8 @@ services:
     volumes:
     - ../../ops/grafana:/var/lib/grafana  
 
-  admin:
-    build: ../admin
-    ports: ["3010:3010"]
-    depends_on:
-      - redis
+  #admin:
+  #  build: ../admin
+  #  ports: ["3010:3010"]
+  #  depends_on:
+  #    - redis