import (
    "github.com/XiaoConstantine/dspy-go/pkg/core"
    "github.com/XiaoConstantine/dspy-go/pkg/llms"
)

// Basic setup
llm, err := llms.NewGeminiLLM("your-api-key", core.ModelGoogleGeminiPro)
if err != nil {
    log.Fatal(err)
}
core.SetDefaultLLM(llm)

llm, err := llms.NewGeminiLLM("api-key", core.ModelGoogleGeminiPro,
    llms.WithTemperature(0.7),      // Creativity (0.0-1.0)
    llms.WithMaxTokens(2048),        // Max output tokens
    llms.WithTopP(0.9),              // Nucleus sampling
    llms.WithTopK(40),               // Top-K sampling
    llms.WithStopSequences([]string{"END", "\n\n"}),
)

// Analyze images
imageData, _ := os.ReadFile("image.jpg")
result, err := predictor.Process(ctx, map[string]interface{}{
    "image": core.NewImageContent(imageData, "image/jpeg"),
    "question": "What's in this image?",
})

// Multiple images
result, err := predictor.Process(ctx, map[string]interface{}{
    "image1": core.NewImageContent(data1, "image/jpeg"),
    "image2": core.NewImageContent(data2, "image/jpeg"),
    "question": "What changed between these images?",
})

llm.SetStreaming(true)

// Handle streaming chunks
llm.SetStreamHandler(func(chunk string) {
    fmt.Print(chunk)
})

result, err := llm.Generate(ctx, prompt)

// ✅ Use 2.5-flash for speed and cost
llm, _ := llms.NewGeminiLLM(key, core.ModelGoogleGeminiFlash)

// ✅ Leverage 2M token context for RAG
// No need to chunk! Can handle entire codebases

// ✅ Use for multimodal tasks
llm, _ := llms.NewGeminiLLM(key, core.ModelGoogleGeminiPro)

import (
    "github.com/XiaoConstantine/dspy-go/pkg/core"
    "github.com/XiaoConstantine/dspy-go/pkg/llms"
)

// Basic setup
llm, err := llms.NewOpenAI(core.ModelOpenAIGPT5, "your-api-key")
core.SetDefaultLLM(llm)

llm, err := llms.NewOpenAI(core.ModelOpenAIGPT5, "api-key",
    llms.WithTemperature(0.7),           // Creativity
    llms.WithMaxTokens(4096),             // Max output
    llms.WithTopP(0.9),                   // Nucleus sampling
    llms.WithPresencePenalty(0.1),        // Discourage repetition
    llms.WithFrequencyPenalty(0.1),       // Penalize frequent words
    llms.WithStopSequences([]string{"\n\n"}),
)

// Define functions
functions := []core.Function{
    {
        Name:        "get_weather",
        Description: "Get current weather for a location",
        Parameters: map[string]interface{}{
            "type": "object",
            "properties": map[string]interface{}{
                "location": map[string]interface{}{
                    "type": "string",
                    "description": "City name",
                },
            },
            "required": []string{"location"},
        },
    },
}

llm.SetFunctions(functions)

llm, err := llms.NewOpenAI("gpt-5", "api-key",
    llms.WithBaseURL("https://your-resource.openai.azure.com"),
    llms.WithAPIVersion("2024-02-15-preview"),
    llms.WithAPIType("azure"),
)

llm.SetStreaming(true)
llm.SetStreamHandler(func(chunk string) {
    fmt.Print(chunk)
})

result, err := llm.Generate(ctx, prompt)

// ✅ Use GPT-5 for most complex reasoning
llm, _ := llms.NewOpenAI(core.ModelOpenAIGPT5, key)

// ✅ Use gpt-5-nano for high-volume tasks
llm, _ := llms.NewOpenAI(core.ModelOpenAIGPT5Nano, key)

// ✅ Use gpt-4o for production balance
llm, _ := llms.NewOpenAI(core.ModelOpenAIGPT4o, key)

// ✅ Implement retry logic
llm.SetMaxRetries(3)
llm.SetRetryDelay(time.Second)

import (
    "github.com/XiaoConstantine/dspy-go/pkg/core"
    "github.com/XiaoConstantine/dspy-go/pkg/llms"
)

// Basic setup
llm, err := llms.NewAnthropicLLM("your-api-key", core.ModelAnthropicSonnet)
core.SetDefaultLLM(llm)

llm, err := llms.NewAnthropicLLM("api-key", core.ModelAnthropicSonnet,
    llms.WithTemperature(0.7),
    llms.WithMaxTokens(4096),
    llms.WithTopP(0.9),
    llms.WithTopK(40),
)

// Analyze images with Claude
imageData, _ := os.ReadFile("document.jpg")
result, err := predictor.Process(ctx, map[string]interface{}{
    "image": core.NewImageContent(imageData, "image/jpeg"),
    "question": "Extract all text from this document",
})

llm.SetStreaming(true)
llm.SetStreamHandler(func(chunk string) {
    fmt.Print(chunk)
})

result, err := llm.Generate(ctx, prompt)

// ✅ Use 3.5 Sonnet for production
llm, _ := llms.NewAnthropicLLM(key, core.ModelAnthropicSonnet)

// ✅ Use Haiku for fast, cheap tasks
llm, _ := llms.NewAnthropicLLM(key, core.ModelAnthropicHaiku)

// ✅ Leverage 200K context for documents
// Can analyze entire books!

import (
    "github.com/XiaoConstantine/dspy-go/pkg/llms"
)

// Basic setup (assumes Ollama running on localhost:11434)
llm, err := llms.NewOllamaLLM("llama3:8b")

// Custom server
llm, err := llms.NewOllamaLLM("qwen2.5:7b",
    llms.WithBaseURL("http://192.168.1.100:11434"),
)

llm, err := llms.NewOllamaLLM("llama3.1:8b",
    llms.WithTemperature(0.8),
    llms.WithNumCtx(8192),          // Context window
    llms.WithNumPredict(2048),      // Max tokens
    llms.WithNumGPU(1),             // GPU layers
    llms.WithRepeatPenalty(1.1),    // Repetition penalty
)

llm.SetStreaming(true)
llm.SetStreamHandler(func(chunk string) {
    fmt.Print(chunk)
})

result, err := llm.Generate(ctx, prompt)

// Use Ollama for embeddings
llm, err := llms.NewOllamaLLM("nomic-embed-text")
embeddings, err := llm.CreateEmbedding(ctx, "text to embed")

// ✅ Use Llama 3.2 for latest capabilities
llm, _ := llms.NewOllamaLLM("llama3.2:3b")

// ✅ Use Qwen 2.5 for best reasoning
llm, _ := llms.NewOllamaLLM("qwen2.5:7b")

// ✅ Use CodeLlama for code tasks
llm, _ := llms.NewOllamaLLM("codellama:13b")

// ✅ Batch requests for efficiency

// Basic setup (assumes llama.cpp server on localhost:8080)
llm, err := llms.NewLlamacppLLM("http://localhost:8080")
if err != nil {
    log.Fatal(err)
}
core.SetDefaultLLM(llm)

// Custom configuration
llm, err := llms.NewLlamacppLLM("http://localhost:8080",
    llms.WithTemperature(0.7),
    llms.WithMaxTokens(2048),
)

llm, err := llms.NewLlamacppLLM("http://localhost:8080",
    llms.WithTemperature(0.8),
    llms.WithTopK(40),
    llms.WithTopP(0.9),
    llms.WithRepeatPenalty(1.1),
)

llm.SetStreaming(true)
llm.SetStreamHandler(func(chunk string) {
    fmt.Print(chunk)
})

result, err := llm.Generate(ctx, prompt)

// ✅ Use Q4_K_M for balance
// Good quality, reasonable size

// ✅ Use Q5_K_M for better quality
// Slightly larger, better output

// ✅ Monitor GPU memory usage
// Adjust context size if needed

// ✅ Use --ctx-size for long contexts
./server -m model.gguf --ctx-size 8192

// Basic setup (assumes LiteLLM proxy running)
config := core.ProviderConfig{
    Name:    "litellm",
    BaseURL: "http://localhost:4000",
}

llm, err := llms.LiteLLMProviderFactory(ctx, config, "gpt-4")
core.SetDefaultLLM(llm)

// With API key
llm, err := llms.LiteLLMProviderFactory(ctx, config, "claude-3-sonnet",
    llms.WithAPIKey("your-litellm-key"),
)

// Use any provider through LiteLLM
config := core.ProviderConfig{
    Name:    "litellm",
    BaseURL: "http://localhost:4000",
}

// OpenAI GPT-4
llmGPT4, _ := llms.LiteLLMProviderFactory(ctx, config, "gpt-4")

// Anthropic Claude
llmClaude, _ := llms.LiteLLMProviderFactory(ctx, config, "claude-3-sonnet")

// Together AI Llama
llmLlama, _ := llms.LiteLLMProviderFactory(ctx, config, "llama-3-70b")

# litellm_config.yaml - Advanced routing
router_settings:
  routing_strategy: least-busy

model_list:
  - model_name: gpt-4
    litellm_params:
      model: openai/gpt-4
      api_key: os.environ/OPENAI_API_KEY

  - model_name: gpt-4
    litellm_params:
      model: azure/gpt-4
      api_key: os.environ/AZURE_API_KEY
      api_base: os.environ/AZURE_ENDPOINT

// LiteLLM automatically load balances
// Just configure multiple instances in litellm_config.yaml
llm, err := llms.LiteLLMProviderFactory(ctx, config, "gpt-4")
// Requests automatically distributed across providers

// ✅ Use for multi-provider applications
// Switch providers without code changes

// ✅ Implement fallback logic
// LiteLLM can auto-fallback to backup models

// ✅ Monitor costs centrally
// Single dashboard for all providers

// ✅ Use for A/B testing
// Easy to compare different models

// Implement exponential backoff
llm.SetMaxRetries(5)
llm.SetRetryDelay(2 * time.Second)
llm.SetRetryBackoff(true)

// Check model's context window
maxContext := llm.GetContextWindow()

// Truncate if needed
if len(prompt) > maxContext {
    prompt = prompt[:maxContext]
}

// Verify API key is set
apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
    log.Fatal("API key not found")
}

// Test with simple request
result, err := llm.Generate(ctx, "Hello, world!")