Add multi-LLM provider support (Anthropic + OpenAI)

Introduce an LLMClient interface so the RAG chain can work with any LLM
provider. Add OpenAI Chat Completions client alongside the existing Claude
client, selectable via LLM_PROVIDER env var.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: gyaan

.env_example

@@ -0,0 +1,11 @@
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+SERVER_PORT=8080
+KNOWLEDGE_BASE_PATH=./knowledge_base
+CHUNK_SIZE=500
+CHUNK_OVERLAP=50
+TOP_K=5
+CLAUDE_MODEL=claude-sonnet-4-5-20250929
+SESSION_TTL_HOURS=24
+LLM_PROVIDER=anthropic
+OPENAI_API_KEY=
+OPENAI_MODEL=gpt-4o

CLAUDE.md

@@ -0,0 +1,84 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+**customer-support-rag** is a production-ready RAG (Retrieval-Augmented Generation) system that serves API endpoints for a frontend to answer customer queries. It uses a knowledge base of FAQs, product docs, and help center articles as context, with Claude as the LLM and a pure Go TF-IDF engine for embeddings with an in-memory vector store for semantic search.
+
+- **Repository**: https://github.com/gyaan/knowledge-pipeline.git
+- **License**: MIT
+- **Language**: Go 1.25.6 (macOS ARM64)
+- **External dependencies**: None (pure standard library)
+
+## Build & Run Commands
+
+```bash
+go build ./...                                      # build all packages
+go test ./...                                       # run all tests
+go test -run TestName ./path/to/package             # run a single test
+go vet ./...                                        # static analysis
+
+# Dry-run ingestion (loads KB, chunks, builds TF-IDF, prints stats)
+go run cmd/ingest/main.go
+
+# Run the API server (ingests KB on startup, serves on :8080)
+go run cmd/server/main.go
+```
+
+## Architecture
+
+```
+Startup: Load docs → Split → Build TF-IDF vocab → Embed chunks → Store in vector DB
+Request: POST /api/chat → Embed query → Vector search → Build context → Claude LLM → Response
+```
+
+### Entry Points
+- **cmd/ingest/** — Dry-run CLI: loads knowledge base, chunks, builds TF-IDF vocab, prints stats (no server)
+- **cmd/server/** — Ingests KB at startup, then serves HTTP API with graceful shutdown (SIGINT/SIGTERM)
+
+### Internal Packages (data flow order)
+1. **config/** — Loads .env: API key, server port, KB path, chunk settings, model, session TTL
+2. **documents/** — `loader.go` reads .txt files with category/filename metadata, skips empty; `splitter.go` chunks with overlap
+3. **embeddings/** — `client.go` defines `Embedder` interface; `server.go` implements pure Go TF-IDF engine
+4. **vectordb/** — `memory.go` in-memory store (no disk persistence); `search.go` cosine similarity
+5. **llm/** — `client.go` defines `LLMClient` interface; `claude.go` Anthropic client; `openai.go` OpenAI client
+6. **rag/** — `chain.go` orchestrates: query → embed → vector search → build prompt → call LLM → return
+7. **session/** — `manager.go` manages conversation history with configurable TTL, crypto/rand IDs, stoppable cleanup
+8. **api/** — `server.go` HTTP router with graceful shutdown; `handlers.go` defines ChatHandler + HealthHandler
+
+### Shared Types
+- **pkg/models/** — `types.go` defines shared structs (Document, ChatRequest/Response, Session, Claude/OpenAI API types)
+
+### API Endpoints
+- `POST /api/chat` — `{"query": "...", "session_id": "..."}` → `{"session_id": "...", "answer": "...", "sources": [...]}`
+- `GET /api/health` — `{"status": "healthy", "active_sessions": N, "documents": N}`
+
+### Knowledge Base (`knowledge_base/`)
+- **faq/** — general, billing, technical, account FAQs
+- **product_docs/** — getting started, features, API docs, integrations
+- **help_center/** — troubleshooting, best practices, tutorials
+
+## Environment Variables (.env)
+
+```
+ANTHROPIC_API_KEY=         # Claude API key (required when LLM_PROVIDER=anthropic)
+SERVER_PORT=8080           # HTTP server port
+KNOWLEDGE_BASE_PATH=./knowledge_base
+CHUNK_SIZE=500
+CHUNK_OVERLAP=50
+TOP_K=5
+CLAUDE_MODEL=claude-sonnet-4-5-20250929
+SESSION_TTL_HOURS=24
+LLM_PROVIDER=anthropic     # anthropic or openai
+OPENAI_API_KEY=            # OpenAI API key (required when LLM_PROVIDER=openai)
+OPENAI_MODEL=gpt-4o        # OpenAI model name
+```
+
+## Conventions
+- Zero external dependencies — pure `net/http` + standard library only
+- In-memory vector store (no external DB, no disk persistence)
+- Pure Go TF-IDF embeddings (no Python, no external embedding service)
+- Standard Go project layout: `cmd/`, `internal/`, `pkg/`
+- Configuration via `.env` file (gitignored)
+- Graceful shutdown with signal handling

cmd/ingest/main.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"flag"
+	"log"
+
+	"github.com/gyaan/knowledge-pipeline/internal/config"
+	"github.com/gyaan/knowledge-pipeline/internal/documents"
+	"github.com/gyaan/knowledge-pipeline/internal/embeddings"
+)
+
+func main() {
+	docsPath := flag.String("docs", "", "Path to documents directory (overrides config)")
+	flag.Parse()
+
+	log.Println("Starting document ingestion (dry run)...")
+
+	cfg, err := config.Load()
+	if err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	path := cfg.KnowledgeBasePath
+	if *docsPath != "" {
+		path = *docsPath
+	}
+
+	// Load documents
+	loader := documents.NewLoader()
+	log.Printf("Loading documents from %s...", path)
+	docs, err := loader.LoadFromDirectory(path)
+	if err != nil {
+		log.Fatalf("Failed to load documents: %v", err)
+	}
+	log.Printf("Loaded %d documents", len(docs))
+
+	for _, doc := range docs {
+		log.Printf("  - %s (%s/%s, %d chars)",
+			doc.Metadata["filename"],
+			doc.Metadata["category"],
+			doc.Metadata["type"],
+			len(doc.Content))
+	}
+
+	// Split into chunks
+	splitter := documents.NewSplitter(cfg.ChunkSize, cfg.ChunkOverlap)
+	chunks := splitter.Split(docs)
+	log.Printf("Created %d chunks (size=%d, overlap=%d)", len(chunks), cfg.ChunkSize, cfg.ChunkOverlap)
+
+	// Build TF-IDF vocabulary
+	tfidf := embeddings.NewTFIDFEngine()
+	texts := make([]string, len(chunks))
+	for i, chunk := range chunks {
+		texts[i] = chunk.Content
+	}
+	tfidf.BuildVocabulary(texts)
+	log.Printf("Built TF-IDF vocabulary: %d unique terms", tfidf.VocabSize())
+
+	// Embed all chunks
+	vecs := tfidf.EmbedBatch(texts)
+
+	nonZero := 0
+	for _, v := range vecs {
+		for _, val := range v {
+			if val != 0 {
+				nonZero++
+				break
+			}
+		}
+	}
+
+	log.Printf("Generated %d embeddings (%d non-zero vectors, dim=%d)",
+		len(vecs), nonZero, tfidf.VocabSize())
+	log.Println("Dry run complete. Use cmd/server to run with live ingestion.")
+}

cmd/server/main.go

@@ -0,0 +1,94 @@
+package main
+
+import (
+	"context"
+	"log"
+	"os/signal"
+	"syscall"
+
+	"github.com/gyaan/knowledge-pipeline/internal/api"
+	"github.com/gyaan/knowledge-pipeline/internal/config"
+	"github.com/gyaan/knowledge-pipeline/internal/documents"
+	"github.com/gyaan/knowledge-pipeline/internal/embeddings"
+	"github.com/gyaan/knowledge-pipeline/internal/llm"
+	"github.com/gyaan/knowledge-pipeline/internal/rag"
+	"github.com/gyaan/knowledge-pipeline/internal/session"
+	"github.com/gyaan/knowledge-pipeline/internal/vectordb"
+)
+
+func main() {
+	log.Println("Starting Customer Support RAG Server...")
+
+	// Load configuration
+	cfg, err := config.Load()
+	if err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Validate API key for selected provider
+	var llmClient llm.LLMClient
+	switch cfg.LLMProvider {
+	case "openai":
+		if cfg.OpenAIAPIKey == "" {
+			log.Fatal("OPENAI_API_KEY must be set in .env when LLM_PROVIDER=openai")
+		}
+		llmClient = llm.NewOpenAIClient(cfg.OpenAIAPIKey, cfg.OpenAIModel)
+		log.Printf("Using OpenAI provider (model: %s)", cfg.OpenAIModel)
+	default:
+		if cfg.AnthropicAPIKey == "" || cfg.AnthropicAPIKey == "your_anthropic_api_key_here" {
+			log.Fatal("ANTHROPIC_API_KEY must be set in .env when LLM_PROVIDER=anthropic")
+		}
+		llmClient = llm.NewClaudeClient(cfg.AnthropicAPIKey, cfg.ClaudeModel)
+		log.Printf("Using Anthropic provider (model: %s)", cfg.ClaudeModel)
+	}
+
+	// Load documents
+	log.Printf("Loading knowledge base from %s...", cfg.KnowledgeBasePath)
+	loader := documents.NewLoader()
+	docs, err := loader.LoadFromDirectory(cfg.KnowledgeBasePath)
+	if err != nil {
+		log.Fatalf("Failed to load documents: %v", err)
+	}
+	log.Printf("Loaded %d documents", len(docs))
+
+	// Split into chunks
+	splitter := documents.NewSplitter(cfg.ChunkSize, cfg.ChunkOverlap)
+	chunks := splitter.Split(docs)
+	log.Printf("Created %d chunks", len(chunks))
+
+	// Build TF-IDF vocabulary and embed chunks
+	tfidf := embeddings.NewTFIDFEngine()
+	texts := make([]string, len(chunks))
+	for i, chunk := range chunks {
+		texts[i] = chunk.Content
+	}
+	tfidf.BuildVocabulary(texts)
+	log.Printf("Built TF-IDF vocabulary: %d terms", tfidf.VocabSize())
+
+	vecs := tfidf.EmbedBatch(texts)
+	for i := range chunks {
+		chunks[i].Embedding = vecs[i]
+	}
+
+	// Store in vector database
+	vectorDB := vectordb.NewMemoryVectorDB()
+	vectorDB.Add(chunks)
+	log.Printf("Indexed %d chunks in vector store", vectorDB.Count())
+
+	// Initialize remaining components
+	ragChain := rag.NewChain(tfidf, vectorDB, llmClient, cfg.TopK)
+	sessionManager := session.NewManager(cfg.SessionTTLHours)
+	handlers := api.NewHandlers(ragChain, sessionManager, vectorDB)
+	server := api.NewServer(handlers, cfg.ServerPort)
+
+	// Graceful shutdown on SIGINT/SIGTERM
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	if err := server.Start(ctx); err != nil {
+		log.Printf("Server stopped: %v", err)
+	}
+
+	sessionManager.Stop()
+	log.Println("Shutdown complete")
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/gyaan/knowledge-pipeline
+
+go 1.25.6

internal/api/handlers.go

@@ -0,0 +1,93 @@
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/gyaan/knowledge-pipeline/internal/rag"
+	"github.com/gyaan/knowledge-pipeline/internal/session"
+	"github.com/gyaan/knowledge-pipeline/internal/vectordb"
+	"github.com/gyaan/knowledge-pipeline/pkg/models"
+)
+
+type Handlers struct {
+	ragChain       *rag.Chain
+	sessionManager *session.Manager
+	vectorDB       *vectordb.MemoryVectorDB
+}
+
+func NewHandlers(ragChain *rag.Chain, sessionManager *session.Manager, vectorDB *vectordb.MemoryVectorDB) *Handlers {
+	return &Handlers{
+		ragChain:       ragChain,
+		sessionManager: sessionManager,
+		vectorDB:       vectorDB,
+	}
+}
+
+// ChatHandler handles chat requests.
+func (h *Handlers) ChatHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req models.ChatRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if req.Query == "" {
+		http.Error(w, "Query is required", http.StatusBadRequest)
+		return
+	}
+
+	sess := h.sessionManager.GetOrCreate(req.SessionID)
+
+	// Add user message to session
+	userMsg := models.ChatMessage{
+		Role:      "user",
+		Content:   req.Query,
+		Timestamp: time.Now(),
+	}
+	h.sessionManager.AddMessage(sess.ID, userMsg)
+
+	// Get chat history (exclude the message we just added)
+	history := sess.Messages[:len(sess.Messages)-1]
+
+	response, err := h.ragChain.Query(r.Context(), req.Query, history)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Error processing query: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	// Add assistant message to session
+	assistantMsg := models.ChatMessage{
+		Role:      "assistant",
+		Content:   response.Answer,
+		Timestamp: time.Now(),
+	}
+	h.sessionManager.AddMessage(sess.ID, assistantMsg)
+
+	response.SessionID = sess.ID
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(response)
+}
+
+// HealthHandler returns health status.
+func (h *Handlers) HealthHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]interface{}{
+		"status":          "healthy",
+		"active_sessions": h.sessionManager.Count(),
+		"documents":       h.vectorDB.Count(),
+	})
+}