DSPy-Go

https://github.com/xiaoconstantine/dspy-go
Admin
DSPy-Go is a native Go implementation of the DSPy framework, bringing systematic prompt engineering...
Tokens:94,267
Snippets:1,153
Trust Score:9.3
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install LiteLLM and Start Proxy

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Instructions for installing LiteLLM, creating a configuration file, and starting the proxy server.

```bash
# Install LiteLLM
pip install litellm[proxy]

# Create config file
cat > litellm_config.yaml <<EOF
model_list:
  - model_name: gpt-4
    litellm_params:
      model: openai/gpt-4
      api_key: os.environ/OPENAI_API_KEY

  - model_name: claude-3-sonnet
    litellm_params:
      model: anthropic/claude-3-sonnet-20240229
      api_key: os.environ/ANTHROPIC_API_KEY

  - model_name: llama-3-70b
    litellm_params:
      model: together_ai/meta-llama/Llama-3-70b-chat-hf
      api_key: os.environ/TOGETHER_API_KEY
EOF

# Start proxy server
litellm --config litellm_config.yaml --port 4000
```

--------------------------------

### Quick Start: List, Recommend, Try, and Compare Optimizers

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/cli.md

A sequence of commands to get started with dspy-cli: list available optimizers, get a recommendation, try a specific optimizer on a dataset, and compare its performance.

```bash
# 1. List available optimizers
dspy-cli list

# 2. Get a recommendation
dspy-cli recommend balanced

# 3. Try the recommended optimizer
dspy-cli try mipro --dataset gsm8k --max-examples 10

# 4. Compare with others
dspy-cli compare bootstrap mipro --max-examples 10
```

--------------------------------

### Zero-Config LLM Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/configuration.md

Automatically configure the default LLM by detecting and setting it based on environment variables. This is the simplest way to get started.

```go
import "github.com/XiaoConstantine/dspy-go/pkg/core"

func main() {
    // Detects and configures LLM from environment
    llm, err := llms.NewGeminiLLM("", core.ModelGoogleGeminiPro)
    if err != nil {
        log.Fatal(err)
    }
    core.SetDefaultLLM(llm)

    // Ready to use modules
    predictor := modules.NewPredict(signature)
}
```

--------------------------------

### Install and Run DSPy-CLI

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/cmd/dspy-cli/README.md

Install the DSPy-CLI by building it from source, set your API key, and then run various commands to try optimizers, list available optimizers, describe specific optimizers, or get optimizer recommendations.

```bash
cd cmd/dspy-cli
go build -o dspy-cli

export GEMINI_API_KEY="your-api-key-here"

./dspy-cli try bootstrap --dataset gsm8k --max-examples 5

./dspy-cli list

./dspy-cli describe mipro

./dspy-cli recommend advanced
```

--------------------------------

### Run Tool Composition Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/tools.md

Navigate to the tool_composition directory and execute the main Go program to run the example.

```bash
cd examples/tool_composition && go run main.go
```

--------------------------------

### Run DSPy Go Examples

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/xml_adapter/README.md

Execute different DSPy Go examples by navigating to their respective directories and running the Go program. Ensure Go 1.21+ is installed.

```bash
(cd basic_usage && go run basic_usage.go)
(cd composable && go run composable.go)
(cd custom_config && go run custom_config.go)
(cd predict_xml && go run predict_xml_example.go)
(cd react_xml && go run react_xml_example.go)
```

--------------------------------

### Production Pipeline Interceptor Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/interceptors.md

This example shows how to build a production-ready interceptor chain, including setting up caching, circuit breakers, retry configurations, and then applying them to a module.

```go
// Create caching
cache := interceptors.NewMemoryCache()

// Create circuit breaker
cb := interceptors.NewCircuitBreaker(5, 30*time.Second, 10)

// Create retry config
retryConfig := interceptors.RetryConfig{
    MaxAttempts: 3,
    Delay:       100*time.Millisecond,
    Backoff:     2.0,
}

// Build production chain
chain := []core.ModuleInterceptor{
    interceptors.LoggingModuleInterceptor(),
    interceptors.ValidationModuleInterceptor(interceptors.DefaultValidationConfig()),
    interceptors.RetryModuleInterceptor(retryConfig),
    interceptors.CircuitBreakerModuleInterceptor(cb),
    interceptors.CachingModuleInterceptor(cache, 10*time.Minute),
    interceptors.TimeoutModuleInterceptor(30*time.Second),
    interceptors.MetricsModuleInterceptor(),
}

predict := modules.NewPredict(signature)
predict.SetInterceptors(chain)
```

--------------------------------

### Complete dspy-cli Workflow Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/cmd/dspy-cli/README.md

Demonstrates a typical workflow for exploring and testing dspy optimizers using the command line. This includes listing available optimizers, getting recommendations, describing a specific optimizer, and testing it with a dataset.

```bash
# 1. Explore available optimizers
dspy-cli list

# 2. Get recommendations for your use case
dspy-cli recommend balanced

# 3. Learn about a specific optimizer
dspy-cli describe mipro

# 4. Test the optimizer with sample data
dspy-cli try mipro --dataset gsm8k --max-examples 5 --verbose

# 5. Compare with other optimizers
dspy-cli try bootstrap --dataset gsm8k --max-examples 5
dspy-cli try simba --dataset gsm8k --max-examples 5
```

--------------------------------

### Run Smart Tool Registry Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/tools.md

Navigate to the smart_tool_registry directory and execute the main Go program to run the example.

```bash
cd examples/smart_tool_registry && go run main.go
```

--------------------------------

### Run Basic Agent Examples

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/agents.md

Navigate to the 'examples/agents' directory and execute the main Go program to run basic agent examples.

```bash
# Basic agent examples
cd examples/agents && go run main.go
```

--------------------------------

### llama.cpp Installation and Server Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Provides bash commands to clone the llama.cpp repository, build it (optionally with CUDA support), download a GGUF model, and start the local server.

```bash
# Clone llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Build with GPU support (optional)
make LLAMA_CUBLAS=1

# Download a GGUF model from Hugging Face
# Example: https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF
wget https://huggingface.co/.../llama-2-7b-chat.Q4_K_M.gguf

# Start server
./server -m llama-2-7b-chat.Q4_K_M.gguf --port 8080
```

--------------------------------

### BootstrapFewShot Optimizer Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/optimizers.md

Demonstrates how to create and use the BootstrapFewShot optimizer. Configure with maximum bootstrapped and labeled demos. Suitable for getting started and simple to medium complexity tasks.

```go
package main

import (
    "context"
    "github.com/XiaoConstantine/dspy-go/pkg/optimizers"
    "github.com/XiaoConstantine/dspy-go/pkg/metrics"
)

func main() {
    // Create Bootstrap optimizer
    bootstrap := optimizers.NewBootstrapFewShot(
        dataset,
        metrics.NewExactMatchMetric("answer"),
        optimizers.WithMaxBootstrappedDemos(5),      // Max examples
        optimizers.WithMaxLabeledDemos(3),           // Max labeled examples
    )

    // Optimize module
    optimizedModule, err := bootstrap.Optimize(ctx, originalModule)
    if err != nil {
        log.Fatal(err)
    }

    // Use optimized module
    result, _ := optimizedModule.Process(ctx, inputs)
}
```

--------------------------------

### Run Tool Chaining Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/tools.md

Navigate to the tool_chaining directory and execute the main Go program to run the example.

```bash
cd examples/tool_chaining && go run main.go
```

--------------------------------

### Run DSPy-Go Examples

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/README.md

Demonstrates how to run various DSPy-Go examples from the repository root using the `go run` command. Some examples require specific environment variables like API keys.

```bash
go run ./examples/rlm_subrlm_budgets
```

```bash
go run ./examples/parallel
```

```bash
GEMINI_API_KEY=... go run ./examples/rlm_context_policy -provider gemini
```

```bash
GOOGLE_API_KEY=... go run ./examples/rlm_oolong_gepa -provider gemini -artifact /tmp/oolong-program.json
```

--------------------------------

### Install dspy-go

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/README.md

Install the dspy-go library using the go get command.

```bash
go get github.com/XiaoConstantine/dspy-go
```

--------------------------------

### Navigate and Run DSPy Go Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/refine/README.md

Change directory to the example folder and execute the main Go program. This initiates the DSPy refinement process.

```bash
cd examples/refine
go run main.go
```

--------------------------------

### Basic LiteLLM Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Configure and initialize the LiteLLM provider with a base URL. Assumes the LiteLLM proxy is already running.

```go
// 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)
```

--------------------------------

### Run Complete A2A Composition Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/a2a-protocol.md

Navigate to the example directory and run the main Go program to execute the deep research agent example. Replace YOUR_API_KEY with your actual API key.

```bash
cd examples/a2a_composition
go run main.go --api-key YOUR_API_KEY
```

--------------------------------

### GEPA Optimization Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/optimizers.md

Demonstrates how to configure and run the GEPA optimizer with a dspy-go program, dataset, and custom metric. It shows steps for LLM configuration, program creation, dataset loading, metric definition, GEPA setup, optimization, and accessing results like best fitness and the Pareto archive.

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/XiaoConstantine/dspy-go/pkg/core"
    "github.com/XiaoConstantine/dspy-go/pkg/optimizers"
    "github.com/XiaoConstantine/dspy-go/pkg/datasets"
)

func main() {
    // 1. Configure LLM
    llm, _ := llms.NewGeminiLLM("", core.ModelGoogleGeminiPro)
    core.SetDefaultLLM(llm)

    // 2. Create your program
    program := createMyProgram() // Your application

    // 3. Load dataset
    dataset, _ := datasets.LoadGSM8K("path/to/gsm8k")

    // 4. Define metric
    metricFunc := func(example, prediction map[string]interface{}, trace *core.Trace) (float64, map[string]interface{}) {
        expected := example["answer"].(string)
        actual := prediction["answer"].(string)

        if expected == actual {
            return 1.0, map[string]interface{}{"correct": true}
        }
        return 0.0, map[string]interface{}{"correct": false}
    }

    // 5. Configure GEPA
    config := &optimizers.GEPAConfig{
        PopulationSize:    20,                // Size of population
        MaxGenerations:    10,                // Number of generations
        SelectionStrategy: "adaptive_pareto", // Multi-objective Pareto
        MutationRate:      0.3,               // Mutation probability
        CrossoverRate:     0.7,               // Crossover probability
        ReflectionFreq:    2,                 // LLM reflection every 2 generations
        ElitismRate:       0.1,               // Preserve top 10%
    }

    gepa, err := optimizers.NewGEPA(config)
    if err != nil {
        log.Fatal(err)
    }

    // 6. Optimize
    ctx := context.Background()
    optimizedProgram, err := gepa.Compile(ctx, program, dataset, metricFunc)
    if err != nil {
        log.Fatal(err)
    }

    // 7. Access results
    state := gepa.GetOptimizationState()
    fmt.Printf("Best fitness: %.3f\n", state.BestFitness)
    fmt.Printf("Generations: %d\n", state.CurrentGeneration)

    // 8. Get Pareto archive (multiple solutions optimized for different trade-offs)
    archive := state.GetParetoArchive()
    fmt.Printf("Elite solutions: %d\n", len(archive))

    // Each solution in archive excels in different ways:
    // - Some optimized for speed
    // - Some optimized for accuracy
    // - Some balanced between both
}
```

--------------------------------

### Run MultiChainComparison Examples

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/multi_chain_comparison/README.md

Execute the multi-chain comparison examples using the provided Go command. Ensure you replace YOUR_API_KEY with your actual API key.

```bash
go run examples/multi_chain_comparison/main.go -api-key YOUR_API_KEY
```

--------------------------------

### Complete dspy-go Example: Signatures, Modules, and Programs

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/core-concepts.md

This example demonstrates how to configure an LLM, define a Signature, create a Chain-of-Thought module, assemble them into a Program, and execute it to analyze text. Ensure you have the necessary LLM API keys configured.

```go
package main

import (
    "context"
    "fmt"
    "log"

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

func main() {
    // 1. Configure LLM
    llm, err := llms.NewGeminiLLM("", core.ModelGoogleGeminiPro)
    if err != nil {
        log.Fatal(err)
    }
    core.SetDefaultLLM(llm)

    // 2. Define Signature
    signature := core.NewSignature(
        []core.InputField{
            {Field: core.NewField("text",
                core.WithDescription("The text to analyze"))},
        },
        []core.OutputField{
            {Field: core.NewField("summary",
                core.WithDescription("A concise summary"))},
            {Field: core.NewField("sentiment",
                core.WithDescription("Overall sentiment: Positive/Negative/Neutral"))},
            {Field: core.NewField("key_points",
                core.WithDescription("Main takeaways as bullet points"))},
        },
    ).WithInstruction("Analyze the provided text thoroughly and extract key insights.")

    // 3. Create Modules
    analyzer := modules.NewChainOfThought(signature)

    // 4. Create Program
    program := core.NewProgram(
        map[string]core.Module{"analyzer": analyzer},
        func(ctx context.Context, inputs map[string]interface{}) (map[string]interface{}, error) {
            return analyzer.Process(ctx, inputs)
        },
    )

    // 5. Execute
    result, err := program.Execute(context.Background(), map[string]interface{}{
        "text": "dspy-go provides a systematic approach to building LLM applications...",
    })
    if err != nil {
        log.Fatal(err)
    }

    // 6. Use Results
    fmt.Printf("Summary: %s\n", result["summary"])
    fmt.Printf("Sentiment: %s\n", result["sentiment"])
    fmt.Printf("Key Points: %s\n", result["key_points"])
}
```

--------------------------------

### Basic Ollama LLM Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Initializes a new Ollama LLM client. Assumes Ollama is running on the default localhost:11434. Use this for quick setup.

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

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

--------------------------------

### LiteLLM Setup with API Key

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Initialize the LiteLLM provider with a specific API key for authentication.

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

--------------------------------

### Run ACE Examples

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/agents.md

Execute ACE agent examples using Go. For ACE + ReAct, ensure you set the GEMINI_API_KEY environment variable.

```bash
# ACE examples
go run ./examples/ace_basic/...
GEMINI_API_KEY=your-key go run ./examples/ace_react/...
```

--------------------------------

### Run RLM Sub-RLM Budget Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/rlm_subrlm_budgets/README.md

Execute the RLM Sub-RLM budget example using Go.

```bash
go run ./examples/rlm_subrlm_budgets
```

--------------------------------

### Run Parallel Examples with API Key

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/parallel/README.md

Execute the parallel processing examples by navigating to the directory and running the main Go program with your Google API key.

```bash
cd examples/parallel
go run main.go -api-key="your-google-api-key-here"
```

--------------------------------

### Setting API Key and Running Multimodal Example in Go

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/multimodal.md

Shows how to set the Gemini API key as an environment variable and then navigate to the multimodal example directory to run the main Go program.

```bash
# Set API key
export GEMINI_API_KEY="your-api-key"

# Run multimodal example
cd examples/multimodal && go run main.go
```

--------------------------------

### Basic dspy-go Programming Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/README.md

Demonstrates how to configure an LLM, create a ChainOfThought module with a signature, and execute it to process a question. Ensure you have the necessary imports.

```go
package main

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

func main() {
    // Configure LLM
    llm, err := llms.NewGeminiLLM("", core.ModelGoogleGeminiPro)
    if err != nil {
        panic(err)
    }
    core.SetDefaultLLM(llm)

    // Create signature and module
    signature := core.NewSignature(
        []core.InputField{{Field: core.NewField("question")}},
        []core.OutputField{{Field: core.NewField("answer")}},
    )
    cot := modules.NewChainOfThought(signature)

    // Execute
    result, _ := cot.Process(context.Background(), map[string]interface{}{
        "question": "What is the capital of France?",
    })
    fmt.Println(result["answer"])
}
```

--------------------------------

### Running ACE Examples

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/agents.md

Provides command-line instructions for running the basic ACE example, ACE integrated with a ReAct agent, and persisting learnings across runs using a specified directory.

```bash
# Basic ACE usage (no LLM required)
go run ./examples/ace_basic/...

# ACE integrated with ReAct agent
GEMINI_API_KEY=your-key go run ./examples/ace_react/...

# Persist learnings across runs
go run ./examples/ace_react/... --learnings-dir=./my_learnings
```

--------------------------------

### Run SIMBA Optimizer Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/others/simba/README.md

Execute the Go program to run the SIMBA optimizer example. You can pass the API key as a command-line argument or use the environment variable.

```bash
go run main.go -api-key="your-api-key-here"
```

```bash
go run main.go -api-key="$GOOGLE_API_KEY"
```

--------------------------------

### Install Go Dependencies

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/multimodal/README.md

Download necessary Go modules for the project using 'go mod download'. Ensure Go 1.21+ is installed.

```bash
go mod download
```

--------------------------------

### Copy Install Command to Clipboard

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/layouts/_partials/footer/script-footer-custom.html

Copies the Go install command to the user's clipboard and provides visual feedback. Triggered by a button click or a keyboard shortcut (Ctrl/Cmd + C) when focused on an element with the 'install-command' class.

```javascript
function copyInstallCommand() {
    const command = 'go get github.com/XiaoConstantine/dspy-go';
    navigator.clipboard.writeText(command).then(() => {
        const btn = document.querySelector('.install-copy');
        const originalHTML = btn.innerHTML;
        // Show success state
        btn.innerHTML = ` <svg xmlns="http://www.w3.org/2000/svg" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
            <polyline points="20 6 9 17 4 12"></polyline>
        </svg> `;
        btn.style.color = 'var(--electric-cyan)';
        // Reset after 2 seconds
        setTimeout(() => {
            btn.innerHTML = originalHTML;
            btn.style.color = '';
        }, 2000);
    }).catch(err => {
        console.error('Failed to copy:', err);
    });
}
```

--------------------------------

### YAML Configuration Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/configuration.md

A sample YAML configuration file for dspy-go, specifying LLM, cache, and performance settings.

```yaml
# config.yaml
llm:
  provider: gemini
  model: gemini-1.5-pro
  api_key: ${GEMINI_API_KEY}
  temperature: 0.7
  max_tokens: 2048

cache:
  enabled: true
  directory: ~/.cache/dspy-go
  ttl: 3600

performance:
  max_workers: 4
  rate_limit: 10
  batch_size: 5
```

--------------------------------

### Run A2A Example with Gemini Pro

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/a2a_composition/README.md

Execute the main Go program specifying the 'gemini-pro' model. Replace YOUR_GEMINI_API_KEY with your actual API key.

```bash
go run main.go --api-key YOUR_GEMINI_API_KEY --model gemini-pro
```

--------------------------------

### Basic OpenAI Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Initializes the OpenAI LLM client with a specific model and API key. Sets the initialized LLM as the default for the dspy-go core.

```go
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)
```

--------------------------------

### Run RLM Context Policy Example with Gemini

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/rlm_context_policy/README.md

Execute the RLM context policy example using Google's Gemini API. Ensure the GOOGLE_API_KEY environment variable is set and specify the 'gemini' provider.

```bash
GOOGLE_API_KEY=... go run ./examples/rlm_context_policy -provider gemini
```

--------------------------------

### Run OOLONG GEPA Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/blog/agent-optimization-and-gepa/index.md

Execute the OOLONG example to demonstrate agent optimization against real task outcomes. This command optimizes an adaptive reasoning system using the Gemini provider and Hugging Face models.

```bash
GOOGLE_API_KEY=... go run ./examples/rlm_oolong_gepa \
  -provider gemini \
  -hf \
  -task-offset 20 \
  -tasks 10 \
  -output /tmp/oolong-report.json
```

--------------------------------

### Basic Orchestrator Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/agents.md

Demonstrates how to create a new orchestrator, define subtasks with specific modules, add them to the orchestrator, and execute the overall workflow with input parameters.

```go
package main

import (
    "context"
    "github.com/XiaoConstantine/dspy-go/pkg/agents"
    "github.com/XiaoConstantine/dspy-go/pkg/modules"
)

func main() {
    // Create orchestrator
    orchestrator := agents.NewOrchestrator()

    // Define subtasks with different modules
    researchTask := agents.NewTask("research", researchModule)
    analyzeTask := agents.NewTask("analyze", analyzeModule)
    summarizeTask := agents.NewTask("summarize", summarizeModule)

    // Add tasks to orchestrator
    orchestrator.AddTask(researchTask)
    orchestrator.AddTask(analyzeTask)
    orchestrator.AddTask(summarizeTask)

    // Execute orchestration
    ctx := context.Background()
    result, err := orchestrator.Execute(ctx, map[string]interface{}{
        "topic": "Impact of AI on healthcare",
    })

    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Final Result: %v\n", result)
}
```

--------------------------------

### Custom Ollama Server Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Initializes an Ollama LLM client pointing to a custom server URL. Useful when Ollama is not running on the default address.

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

--------------------------------

### Authorization Interceptor Setup and Policy

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/interceptors.md

Create and configure an authorization interceptor. Define policies with required roles and authentication status for specific modules.

```go
authInterceptor := interceptors.NewAuthorizationInterceptor()
authInterceptor.SetPolicy("sensitive_module", interceptors.AuthorizationPolicy{
    RequiredRoles: []string{"admin", "power_user"},
    RequireAuth:   true,
})

authInterceptor.ModuleAuthorizationInterceptor()
authInterceptor.AgentAuthorizationInterceptor()
authInterceptor.ToolAuthorizationInterceptor()
```

--------------------------------

### Run A2A Example with Gemini Flash

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/a2a_composition/README.md

Execute the main Go program specifying the 'gemini-flash' model. Replace YOUR_GEMINI_API_KEY with your actual API key.

```bash
go run main.go --api-key YOUR_GEMINI_API_KEY --model gemini-flash
```

--------------------------------

### Run Custom XML Configuration Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/xml_adapter/README.md

Demonstrates various XML configuration options, including strict vs flexible parsing, performance optimizations, custom tags, and security settings. Navigate to the directory and run the Go program.

```bash
cd custom_config && go run custom_config.go
```

--------------------------------

### Describe a Specific Optimizer

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/cmd/dspy-cli/README.md

Use the 'describe' command to get detailed information about a particular optimizer, such as its description, complexity, and example applications.

```bash
dspy-cli describe <optimizer>
```

```bash
# Examples
dspy-cli describe mipro
dspy-cli describe bootstrap
dspy-cli describe gepa
```

--------------------------------

### Setup Ollama for Local LLM Execution

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/resources.md

Install Ollama, pull a model like llama2, and set the OLLAMA_BASE_URL environment variable for local LLM execution. This ensures privacy and avoids API costs.

```bash
# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull a model
ollama pull llama2

# Set base URL
export OLLAMA_BASE_URL="http://localhost:11434"
```

--------------------------------

### dspy Prompt Analysis Workflow using TUI

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/cmd/dspy-cli/README.md

Outlines the recommended workflow for analyzing dspy prompt structures using the interactive Text User Interface (TUI). It guides users through starting the TUI, inputting prompts, analyzing components, and exporting the results.

```bash
# 1. Start with the interactive TUI for best experience
dspy-cli

# 2. Select "🔍 Analyze prompt structure"

# 3. Paste or type your prompt in the input area

# 4. Press Tab to analyze and see:
#    - Color-coded component identification
#    - Structure completeness percentage
#    - Missing components highlighted
#    - Optimization recommendations

# 5. Use the color guide to understand each component

# 6. For production use, export the optimized structure:
dspy-cli analyze --export optimized_prompt.yaml "Your final prompt"
```

--------------------------------

### Vision Q&A Example in Go

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/multimodal.md

This Go code snippet shows how to configure a Gemini LLM with vision support, define a signature for analyzing an image with a specific focus, and process the image to get a detailed description, identified objects, dominant colors, and mood. It utilizes the ChainOfThought module for in-depth analysis.

```go
package main

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

func main() {
    // Configure LLM with vision support
    llm, err := llms.NewGeminiLLM("", core.ModelGoogleGeminiPro) // Will use GEMINI_API_KEY
    if err != nil {
        log.Fatal(err)
    }
    core.SetDefaultLLM(llm)

    // Define a comprehensive vision analysis signature
    signature := core.NewSignature(
        []core.InputField{
            {Field: core.NewImageField("image",
                core.WithDescription("The image to analyze in detail"))},
            {Field: core.NewField("focus",
                core.WithDescription("Specific aspect to focus on"))},
        },
        []core.OutputField{
            {Field: core.NewField("description",
                core.WithDescription("Detailed description of the image"))},
            {Field: core.NewField("objects",
                core.WithDescription("List of objects identified"))},
            {Field: core.NewField("colors",
                core.WithDescription("Dominant colors in the image"))},
            {Field: core.NewField("mood",
                core.WithDescription("Overall mood or atmosphere"))},
        },
    ).WithInstruction("Analyze the image thoroughly and provide detailed observations.")

    // Create ChainOfThought for detailed analysis
    analyzer := modules.NewChainOfThought(signature)

    // Load image
    imageData, _ := os.ReadFile("photo.jpg")

    // Analyze
    ctx := context.Background()
    result, err := analyzer.Process(ctx, map[string]interface{}{
        "image": core.NewImageContent(imageData, "image/jpeg"),
        "focus": "architectural details and lighting",
    })

    // Print detailed analysis
    fmt.Printf("Description: %s\n", result["description"])
    fmt.Printf("Objects: %s\n", result["objects"])
    fmt.Printf("Colors: %s\n", result["colors"])
    fmt.Printf("Mood: %s\n", result["mood"])
    fmt.Printf("Reasoning: %s\n", result["rationale"]) // From ChainOfThought
}

```

--------------------------------

### Install dspy-cli Globally

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/cli.md

Install the dspy-cli tool globally using 'go install'. The executable will be placed in your $GOPATH/bin directory.

```bash
cd cmd/dspy-cli
go install
```

--------------------------------

### Install uv Package Manager

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/compatibility_test/README.md

Install the uv package manager using the provided installation script. This is a prerequisite for setting up the Python environment.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Other GEPA Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/blog/agent-optimization-and-gepa/index.md

Access and run the GEPA example located in the 'others' subdirectory.

```shell
./examples/others/gepa
```

--------------------------------

### Initialize and Use Smart Tool Registry

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/tools.md

Demonstrates how to create a Smart Tool Registry with auto-discovery, performance tracking, and fallback enabled. It also shows how to register tools and perform intelligent tool selection based on user intent, followed by execution with performance tracking.

```go
package main

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

func main() {
    // Create Smart Tool Registry
    config := &tools.SmartToolRegistryConfig{
        AutoDiscoveryEnabled:       true,  // Auto-discover from MCP
        PerformanceTrackingEnabled: true,  // Track tool metrics
        FallbackEnabled:           true,   // Intelligent fallback
    }
    registry := tools.NewSmartToolRegistry(config)

    // Register tools
    registry.Register(mySearchTool)
    registry.Register(myAnalysisTool)

    // Intelligent tool selection based on intent
    ctx := context.Background()
    tool, err := registry.SelectBest(ctx, "find user information")
    if err != nil {
        log.Fatal(err)
    }

    // Execute with performance tracking
    result, err := registry.ExecuteWithTracking(ctx, tool.Name(), params)
}
```

--------------------------------

### RLM Oolong GEPA Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/blog/agent-optimization-and-gepa/index.md

Navigate to and run the RLM Oolong GEPA example directory.

```shell
./examples/rlm_oolong_gepa
```

--------------------------------

### Initialize and Execute ReAct Agent

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/pkg/agents/react/README.md

Demonstrates how to create a ReAct agent with advanced features, register tools, and execute a task with interceptors. Use this for a comprehensive agent setup.

```go
package main

import (
    "context"
    "github.com/XiaoConstantine/dspy-go/pkg/agents/react"
    "github.com/XiaoConstantine/dspy-go/pkg/core"
)

func main() {
    // Create agent with all advanced features
    agent := react.NewReActAgent("research-agent", "Research Assistant",
        react.WithExecutionMode(react.ModeHybrid),
        react.WithReflection(true, 3),
        react.WithPlanning(react.Interleaved, 5),
        react.WithMemoryOptimization(24*time.Hour, 0.3),
        react.WithMaxIterations(10),
        react.WithTimeout(5*time.Minute),
    )

    // Initialize with typed signature
    type Input struct {
        Task string `json:"task"`
    }
    type Output struct {
        Result string `json:"result"`
    }

    signature := core.NewTypedSignature[Input, Output]()
    err := agent.Initialize(llm, signature.ToLegacySignature())

    // Register tools
    tools := []core.Tool{searchTool, calculatorTool, summarizerTool}
    for _, tool := range tools {
        agent.RegisterTool(tool)
    }

    // Execute with interceptors for monitoring
    result, err := agent.ExecuteWithInterceptors(
        context.Background(),
        map[string]interface{}{"task": "Analyze market trends"},
        []core.AgentInterceptor{loggingInterceptor, metricsInterceptor},
    )

    // Analyze performance
    history := agent.GetExecutionHistory()
    reflections := agent.Reflector.GetTopReflections(3)
    metrics := agent.Reflector.GetMetrics()
}
```

--------------------------------

### Llama.cpp LLM Configuration Options

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Demonstrates initializing a Llama.cpp LLM client with advanced configuration parameters including temperature, top-k, top-p, and repeat penalty.

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

--------------------------------

### Install Python Dependencies

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/compatibility_test/README.md

Install the required Python packages listed in the requirements.txt file. This ensures all necessary libraries are available for the project.

```bash
pip install -r requirements.txt
```

--------------------------------

### Basic ReAct Agent Implementation

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/agents.md

This Go code demonstrates how to set up and run a basic ReAct agent. It configures an LLM, registers tools like calculator, search, and weather, defines a task signature, and then executes the ReAct module to process a question.

```go
package main

import (
    "context"
    "fmt"
    "log"

    "github.com/XiaoConstantine/dspy-go/pkg/core"
    "github.com/XiaoConstantine/dspy-go/pkg/modules"
    "github.com/XiaoConstantine/dspy-go/pkg/tools"
)

func main() {
    // Configure LLM
    llm, _ := llms.NewGeminiLLM("", core.ModelGoogleGeminiPro)
    core.SetDefaultLLM(llm)

    // Create tools
    calculator := tools.NewCalculatorTool()
    searchTool := tools.NewSearchTool()
    weatherTool := tools.NewWeatherTool()

    // Create tool registry
    registry := tools.NewInMemoryToolRegistry()
    registry.Register(calculator)
    registry.Register(searchTool)
    registry.Register(weatherTool)

    // Define signature for the agent's task
    signature := core.NewSignature(
        []core.InputField{
            {Field: core.NewField("question",
                core.WithDescription("The question to answer"))},
        },
        []core.OutputField{
            {Field: core.NewField("answer",
                core.WithDescription("The final answer"))},
        },
    )

    // Create ReAct module
    react := modules.NewReAct(
        signature,
        registry,
        5, // max iterations
    )

    // Execute
    ctx := context.Background()
    result, err := react.Process(ctx, map[string]interface{}{
        "question": "What is the population of Tokyo divided by 1000?",
    })
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Answer: %s\n", result["answer"])
}
```

--------------------------------

### Install Ollama and Pull Models

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Commands to install Ollama on your system and pull specific language models. This is a prerequisite for local LLM usage.

```bash
# Install Ollama
curl https://ollama.ai/install.sh | sh

# Pull latest models
ollama pull llama3.2:3b
ollama pull qwen2.5:7b

# Run Ollama server
ollama serve
```

--------------------------------

### Basic Llama.cpp LLM Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Initializes a Llama.cpp LLM client connecting to a local server. Assumes the server is running on localhost:8080. Errors during initialization are logged fatally.

```go
llm, err := llms.NewLlamacppLLM("http://localhost:8080")
if err != nil {
    log.Fatal(err)
}
core.SetDefaultLLM(llm)
```

--------------------------------

### No Examples in Dataset Error

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/cmd/dspy-cli/README.md

This error means no examples were found in the specified dataset. Verify the dataset name spelling and check your network connectivity.

```bash
Error: No examples found in dataset
```

--------------------------------

### Run Initial Task

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/native_agent_session/README.md

Execute the first task for the native agent session. This sets up the initial project brief and creates a rollout plan.

```bash
export GEMINI_API_KEY=...
go run ./examples/native_agent_session \
  -reset \
  -task "Read project_brief.md, create rollout_notes.md with a short rollout plan, then finish."
```

--------------------------------

### Install Llama 3.2 1B Model

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/mcp_optimizer/README.md

This command pulls the specified Llama model using Ollama. Ensure Ollama is installed and running before executing.

```bash
ollama pull llama3.2:1b
```

--------------------------------

### Set up Go Workspace

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/cmd/dspy-cli/README.md

Synchronize the Go workspace for seamless development integration with dspy-go.

```bash
# The workspace is already configured in go.work
cd dspy-go
go work sync
```

--------------------------------

### DSPy-CLI Prompt Analyzer Output Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/cmd/dspy-cli/README.md

An example of the output from the DSPy-CLI prompt analyzer, showing component colors, structure completeness, and a breakdown of found and missing components.

```text
📊 Analysis Results

🎨 Component Colors:
  Task Context • Tone Context
  Background Data • Task Rules
  [... complete color guide ...]

Structure Completeness: 90% (9/10 components) • 15 total instances found

✅ Components Found:
  • Task Context: You will be acting as an AI career coach...
  • Tone Context: maintain a friendly customer service tone
  • Background Data: Here is the career guidance document...
  [... detailed breakdown ...]

⚠️ Missing Components:
  • Prefilled Response
```

--------------------------------

### Example LLM Generation with Options

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/configuration.md

Demonstrates how to instantiate and use `GenerateOptions` for an LLM call. Set temperature for creativity and specify stop sequences to control output.

```go
opts := core.GenerateOptions{
    Temperature:   0.7,
    MaxTokens:     2048,
    TopP:          0.9,
    StopSequences: []string{"\n\n", "END"},
}

result, err := llm.GenerateWithOptions(ctx, prompt, opts)
```

--------------------------------

### Run RLM Context Policy Example with Anthropic

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/rlm_context_policy/README.md

Execute the RLM context policy example using Anthropic's API. Ensure the ANTHROPIC_API_KEY environment variable is set.

```bash
ANTHROPIC_API_KEY=... go run ./examples/rlm_context_policy
```

--------------------------------

### Quick Optimizer Validation

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/cmd/dspy-cli/README.md

Provides a quick way to validate that all configured optimizers are functioning correctly. This example tests the 'bootstrap' optimizer with a small number of examples from the 'simple' dataset.

```bash
# Quickly validate that all optimizers are working
dspy-cli try bootstrap --dataset simple --max-examples 2
```

--------------------------------

### Run Basic XML Interceptor Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/xml_adapter/README.md

Demonstrates the fundamental usage of XML interceptors, including creation, application to a module, and automatic XML instruction injection and response parsing. Navigate to the directory and run the Go program.

```bash
cd basic_usage && go run basic_usage.go
```

--------------------------------

### Get Optimizer Recommendations as JSON

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/cli.md

Use the `recommend` command with the `--json` flag to get optimizer suggestions in JSON format. Pipe the output to `jq` to extract specific fields.

```bash
# Get optimizer recommendations as JSON
recommendations=$(dspy-cli recommend balanced --json)
echo "$recommendations" | jq '.recommended_optimizer'
```

--------------------------------

### LLM Initialization Patterns

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/_index.md

Demonstrates different ways to initialize and configure LLMs in dspy-go, from zero-configuration to explicit API key setup and per-module overrides.

```go
// Zero-config (recommended)
llm, _ := llms.NewGeminiLLM("", core.ModelGoogleGeminiPro)
core.SetDefaultLLM(llm)

// Explicit configuration
llm, _ := llms.NewGeminiLLM("api-key", core.ModelGoogleGeminiPro)
core.SetDefaultLLM(llm)

// Per-module override
module := modules.NewPredict(signature)
module.SetLLM(customLLM)
```

--------------------------------

### Run MCP Optimizer Demo

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/mcp_optimizer/README.md

Executes the MCP optimizer demo from the project root directory using Go. This command starts the demo, which includes MCP server integration, optimizer training, and performance testing.

```bash
# From the project root
go run examples/mcp_optimizer/main.go
```

--------------------------------

### Compile and Execute with MIPRO Optimizer

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/optimizers.md

This snippet demonstrates how to configure and use the MIPRO optimizer to compile a program with a given dataset and then execute the optimized program. It shows setting up the LLM, creating the MIPRO optimizer with specific configurations like mode, number of trials, and TPE gamma, and handling potential errors during compilation and execution.

```go
package main

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

func main() {
    // Configure LLM
    llm, _ := llms.NewGeminiLLM("", core.ModelGoogleGeminiPro)
    core.SetDefaultLLM(llm)

    // Create MIPRO optimizer
    mipro := optimizers.NewMIPRO(
        metricFunc,
        optimizers.WithMode(optimizers.LightMode),      // Fast optimization
        optimizers.WithNumTrials(10),                   // Number of trials
        optimizers.WithTPEGamma(0.25),                  // Exploration parameter
        optimizers.WithMinExamplesPerModule(5),         // Min examples needed
    )

    // Optimize program
    optimizedProgram, err := mipro.Compile(ctx, program, dataset, nil)
    if err != nil {
        log.Fatal(err)
    }

    // Use optimized program
    result, _ := optimizedProgram.Execute(ctx, inputs)
}
```

--------------------------------

### Run RLM Context Policy Example with OpenAI

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/rlm_context_policy/README.md

Execute the RLM context policy example using OpenAI's API. Ensure the OPENAI_API_KEY environment variable is set and specify the 'openai' provider.

```bash
OPENAI_API_KEY=... go run ./examples/rlm_context_policy -provider openai
```

--------------------------------

### Run Full HotpotQA Reproduction

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/others/gepa/reproduction/README.md

Navigate to the hotpotqa directory and run the main Go program to perform a complete reproduction of the paper's HotpotQA experiments. Ensure your GEMINI_API_KEY is set.

```bash
cd hotpotqa/
go run main.go -api-key $GEMINI_API_KEY
```

--------------------------------

### Create and Compile with SIMBA Optimizer

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/optimizers.md

Demonstrates how to initialize the SIMBA optimizer with custom parameters and compile a program using it. This is useful for complex reasoning tasks where insights into the optimization process are desired.

```go
package main

import (
    "context"
    "fmt"
    "github.com/XiaoConstantine/dspy-go/pkg/optimizers"
)

func main() {
    // Create SIMBA optimizer
    simba := optimizers.NewSIMBA(
        optimizers.WithSIMBABatchSize(8),            // Mini-batch size
        optimizers.WithSIMBAMaxSteps(12),            // Max optimization steps
        optimizers.WithSIMBANumCandidates(6),        // Candidates per iteration
        optimizers.WithSamplingTemperature(0.2),     // Exploration vs exploitation
    )

    // Optimize
    optimizedProgram, err := simba.Compile(ctx, program, dataset, metricFunc)
    if err != nil {
        log.Fatal(err)
    }

    // Get introspective insights
    state := simba.GetState()
    fmt.Printf("Steps completed: %d\n", state.CurrentStep)
    fmt.Printf("Best score: %.3f\n", state.BestScore)

    // View detailed analysis
    for i, insight := range state.IntrospectionLog {
        fmt.Printf("Insight %d: %s\n", i+1, insight)
    }

    // Example insights SIMBA might provide:
    // - "Longer instructions improved performance by 15%"
    // - "Adding context examples reduced errors in edge cases"
    // - "Temperature 0.7 balanced creativity and accuracy"
}
```

--------------------------------

### Basic Google Gemini LLM Setup

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/providers.md

Initializes a Google Gemini LLM client with an API key and a specific model. Sets the initialized LLM as the default for dspy-go.

```go
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)
```

--------------------------------

### Tune Adaptive Threshold for RLM Context Policy Example with Gemini

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/examples/rlm_context_policy/README.md

Execute the RLM context policy example with Gemini, tuning the adaptive threshold. Ensure the GOOGLE_API_KEY environment variable is set and specify the 'gemini' provider with a custom '-adaptive-threshold'.

```bash
GOOGLE_API_KEY=... go run ./examples/rlm_context_policy -provider gemini -adaptive-threshold 4
```

--------------------------------

### Apply Single Interceptor

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/guides/interceptors.md

Apply a single interceptor to a module. This example shows how to add logging functionality.

```go
import "github.com/XiaoConstantine/dspy-go/pkg/interceptors"

// Apply single interceptor
module.SetInterceptors([]core.ModuleInterceptor{
    interceptors.LoggingModuleInterceptor(),
})
```

--------------------------------

### Build and Run Go dspy-go Comparison (All Optimizers)

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/compatibility_test/README.md

Compile the Go dspy-go comparison tool and run it to test all optimizers. This step is necessary to execute the Go-side compatibility tests.

```bash
go build -o go_comparison go_comparison.go
./go_comparison
```

--------------------------------

### DSPy CLI Configuration File Example

Source: https://github.com/xiaoconstantine/dspy-go/blob/main/docs/content/docs/reference/cli.md

Define persistent settings for the DSPy CLI in the `~/.dspy-cli.yaml` configuration file.

```yaml
# Default LLM provider
default_llm: gemini-1.5-pro

# Default dataset
default_dataset: gsm8k

# Default optimizer
default_optimizer: mipro

# Example limits
max_examples: 20

# Output preferences
output_format: table
colored_output: true
verbose: false

# Performance
timeout: 300
parallel: false
```
Tokens:
Raw