github.com/XiaoConstantine/dspy-go
Advanced tools
DSPy-Go is a native Go implementation of the DSPy framework, bringing systematic prompt engineering and automated reasoning capabilities to Go applications. It provides a flexible and idiomatic framework for building reliable and effective Language Model (LLM) applications through composable modules and workflows.
go get github.com/XiaoConstantine/dspy-go
New to DSPy-Go? Try our interactive CLI tool to explore optimizers instantly:
# Build and try the CLI
cd cmd/dspy-cli
go build -o dspy-cli
# Set your API key
export GEMINI_API_KEY="your-api-key-here"
# Explore optimizers without writing any code
./dspy-cli list # See all optimizers
./dspy-cli try bootstrap --dataset gsm8k # Test Bootstrap with math problems
./dspy-cli try mipro --dataset gsm8k --verbose # Advanced systematic optimization
./dspy-cli recommend balanced # Get optimizer recommendations
The CLI eliminates 60+ lines of boilerplate code and lets you test all optimizers (Bootstrap, MIPRO, SIMBA, GEPA, COPRO) with sample datasets instantly. → Full CLI Documentation
Here's a simple example to get you started with DSPy-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() {
// Configure the default LLM
llms.EnsureFactory()
err := core.ConfigureDefaultLLM("your-api-key", core.ModelAnthropicSonnet)
if err != nil {
log.Fatalf("Failed to configure LLM: %v", err)
}
// Create a signature for question answering
signature := core.NewSignature(
[]core.InputField{{Field: core.NewField("question", core.WithDescription("Question to answer"))}},
[]core.OutputField{{Field: core.NewField("answer", core.WithDescription("Answer to the question"))}},
)
// Create a ChainOfThought module that implements step-by-step reasoning
cot := modules.NewChainOfThought(signature)
// Create a program that executes the module
program := core.NewProgram(
map[string]core.Module{"cot": cot},
func(ctx context.Context, inputs map[string]interface{}) (map[string]interface{}, error) {
return cot.Process(ctx, inputs)
},
)
// Execute the program with a question
result, err := program.Execute(context.Background(), map[string]interface{}{
"question": "What is the capital of France?",
})
if err != nil {
log.Fatalf("Error executing program: %v", err)
}
fmt.Printf("Answer: %s\n", result["answer"])
}
DSPy-Go is built around several key concepts that work together to create powerful LLM applications:
Signatures define the input and output fields for modules, creating a clear contract for what a module expects and produces.
// Create a signature for a summarization task
signature := core.NewSignature(
[]core.InputField{
{Field: core.NewField("document", core.WithDescription("The document to summarize"))},
},
[]core.OutputField{
{Field: core.NewField("summary", core.WithDescription("A concise summary of the document"))},
{Field: core.NewField("key_points", core.WithDescription("The main points from the document"))},
},
)
Signatures can include field descriptions that enhance prompt clarity and improve LLM performance.
Modules are the building blocks of DSPy-Go programs. They encapsulate specific functionalities and can be composed to create complex pipelines. Some key modules include:
The simplest module that makes direct predictions using an LLM.
predict := modules.NewPredict(signature)
result, err := predict.Process(ctx, map[string]interface{}{
"document": "Long document text here...",
})
// result contains "summary" and "key_points"
Implements chain-of-thought reasoning, which guides the LLM to break down complex problems into intermediate steps.
cot := modules.NewChainOfThought(signature)
result, err := cot.Process(ctx, map[string]interface{}{
"question": "Solve 25 × 16 step by step.",
})
// result contains both the reasoning steps and the final answer
Implements the Reasoning and Acting paradigm, allowing LLMs to use tools to solve problems.
// Create tools
calculator := tools.NewCalculatorTool()
searchTool := tools.NewSearchTool()
// Create tool registry and register tools
registry := tools.NewInMemoryToolRegistry()
registry.Register(calculator)
registry.Register(searchTool)
// Create ReAct module with registry
react := modules.NewReAct(signature, registry, 5) // 5 max iterations
result, err := react.Process(ctx, map[string]interface{}{
"question": "What is the population of France divided by 1000?",
})
// ReAct will use the search tool to find the population and the calculator to divide it
Compares multiple reasoning attempts and synthesizes a holistic evaluation, useful for improving decision quality through multiple perspectives.
// Create a signature for problem solving
signature := core.NewSignature(
[]core.InputField{
{Field: core.NewField("problem", core.WithDescription("The problem to solve"))},
},
[]core.OutputField{
{Field: core.NewField("solution", core.WithDescription("The recommended solution"))},
},
)
// Create MultiChainComparison module with 3 reasoning attempts
multiChain := modules.NewMultiChainComparison(signature, 3, 0.7)
// Provide multiple reasoning attempts for comparison
completions := []map[string]interface{}{
{
"rationale": "focus on cost reduction approach",
"solution": "Implement automation to reduce operational costs",
},
{
"reasoning": "prioritize customer satisfaction strategy",
"solution": "Invest in customer service improvements",
},
{
"rationale": "balance short-term and long-term objectives",
"solution": "Gradual optimization with phased implementation",
},
}
result, err := multiChain.Process(ctx, map[string]interface{}{
"problem": "How should we address declining business performance?",
"completions": completions,
})
// result contains "rationale" with holistic analysis and "solution" with synthesized recommendation
Improves prediction quality by running multiple attempts with different temperatures and selecting the best result based on a reward function.
// Define a reward function that evaluates prediction quality
rewardFn := func(inputs, outputs map[string]interface{}) float64 {
// Custom logic to evaluate the quality of the prediction
// Return a score between 0.0 and 1.0
answer := outputs["answer"].(string)
// Example: longer answers might be better for some tasks
return math.Min(1.0, float64(len(answer))/100.0)
}
// Create a Refine module
refine := modules.NewRefine(
modules.NewPredict(signature),
modules.RefineConfig{
N: 5, // Number of refinement attempts
RewardFn: rewardFn,
Threshold: 0.8, // Stop early if this threshold is reached
},
)
result, err := refine.Process(ctx, map[string]interface{}{
"question": "Explain quantum computing in detail.",
})
// Refine will try multiple times with different temperatures and return the best result
Wraps any module to enable concurrent execution across multiple inputs, providing significant performance improvements for batch processing.
// Create any module (e.g., Predict, ChainOfThought, etc.)
baseModule := modules.NewPredict(signature)
// Wrap it with Parallel for concurrent execution
parallel := modules.NewParallel(baseModule,
modules.WithMaxWorkers(4), // Use 4 concurrent workers
modules.WithReturnFailures(true), // Include failed results in output
modules.WithStopOnFirstError(false), // Continue processing even if some fail
)
// Prepare batch inputs
batchInputs := []map[string]interface{}{
{"question": "What is 2+2?"},
{"question": "What is 3+3?"},
{"question": "What is 4+4?"},
}
// Process all inputs in parallel
result, err := parallel.Process(ctx, map[string]interface{}{
"batch_inputs": batchInputs,
})
// Extract results (maintains input order)
results := result["results"].([]map[string]interface{})
for i, res := range results {
if res != nil {
fmt.Printf("Input %d: %s\n", i, res["answer"])
}
}
Programs combine modules into executable workflows. They define how inputs flow through the system and how outputs are produced.
program := core.NewProgram(
map[string]core.Module{
"retriever": retriever,
"generator": generator,
},
func(ctx context.Context, inputs map[string]interface{}) (map[string]interface{}, error) {
// First retrieve relevant documents
retrieverResult, err := retriever.Process(ctx, inputs)
if err != nil {
return nil, err
}
// Then generate an answer using the retrieved documents
generatorInputs := map[string]interface{}{
"question": inputs["question"],
"documents": retrieverResult["documents"],
}
return generator.Process(ctx, generatorInputs)
},
)
Optimizers help improve the performance of your DSPy-Go programs by automatically tuning prompts and module parameters.
Automatically selects high-quality examples for few-shot learning.
// Create a dataset of examples
dataset := datasets.NewInMemoryDataset()
dataset.AddExample(map[string]interface{}{
"question": "What is the capital of France?",
"answer": "The capital of France is Paris.",
})
// Add more examples...
// Create and apply the optimizer
optimizer := optimizers.NewBootstrapFewShot(dataset, metrics.NewExactMatchMetric("answer"))
optimizedModule, err := optimizer.Optimize(ctx, originalModule)
Advanced optimizer that uses TPE (Tree-structured Parzen Estimator) search for systematic prompt optimization.
// Create a MIPRO optimizer with configuration
mipro := optimizers.NewMIPRO(
metricFunc,
optimizers.WithMode(optimizers.LightMode), // Fast optimization mode
optimizers.WithNumTrials(10), // Number of optimization trials
optimizers.WithTPEGamma(0.25), // TPE exploration parameter
)
optimizedProgram, err := mipro.Compile(ctx, program, dataset, nil)
Cutting-edge optimizer with introspective learning capabilities that analyzes its own optimization progress.
// Create a SIMBA optimizer with introspective features
simba := optimizers.NewSIMBA(
optimizers.WithSIMBABatchSize(8), // Mini-batch size for stochastic optimization
optimizers.WithSIMBAMaxSteps(12), // Maximum optimization steps
optimizers.WithSIMBANumCandidates(6), // Candidate programs per iteration
optimizers.WithSamplingTemperature(0.2), // Temperature for exploration vs exploitation
)
optimizedProgram, err := simba.Compile(ctx, program, dataset, metricFunc)
// Access SIMBA's introspective insights
state := simba.GetState()
fmt.Printf("Optimization completed in %d steps with score %.3f\n",
state.CurrentStep, state.BestScore)
// View detailed introspective analysis
for _, insight := range state.IntrospectionLog {
fmt.Printf("Analysis: %s\n", insight)
}
Collaborative optimizer for multi-module prompt optimization.
// Create a COPRO optimizer
copro := optimizers.NewCopro(dataset, metrics.NewRougeMetric("answer"))
optimizedModule, err := copro.Optimize(ctx, originalModule)
State-of-the-art evolutionary optimizer that combines multi-objective Pareto optimization with LLM-based self-reflection for comprehensive prompt evolution.
// Create GEPA optimizer with advanced configuration
config := &optimizers.GEPAConfig{
PopulationSize: 20, // Size of evolutionary population
MaxGenerations: 10, // Maximum number of generations
SelectionStrategy: "adaptive_pareto", // Multi-objective Pareto selection
MutationRate: 0.3, // Probability of mutation
CrossoverRate: 0.7, // Probability of crossover
ReflectionFreq: 2, // LLM-based reflection every 2 generations
ElitismRate: 0.1, // Elite solution preservation rate
}
gepa, err := optimizers.NewGEPA(config)
if err != nil {
log.Fatalf("Failed to create GEPA optimizer: %v", err)
}
// Optimize program with multi-objective evolutionary approach
optimizedProgram, err := gepa.Compile(ctx, program, dataset, metricFunc)
// Access comprehensive optimization results
state := gepa.GetOptimizationState()
fmt.Printf("Optimization completed in %d generations\n", state.CurrentGeneration)
fmt.Printf("Best fitness: %.3f\n", state.BestFitness)
// Access Pareto archive of elite solutions optimized for different trade-offs
archive := state.GetParetoArchive()
fmt.Printf("Elite solutions preserved: %d\n", len(archive))
// Each solution in archive excels in different objectives:
// - Success rate vs efficiency trade-offs
// - Quality vs speed optimizations
// - Robustness vs generalization balance
GEPA Key Features:
DSPy-Go provides powerful abstractions for building more complex agent systems.
Different memory implementations for tracking conversation history.
// Create a buffer memory for conversation history
memory := memory.NewBufferMemory(10) // Keep last 10 exchanges
memory.Add(context.Background(), "user", "Hello, how can you help me?")
memory.Add(context.Background(), "assistant", "I can answer questions and help with tasks. What do you need?")
// Retrieve conversation history
history, err := memory.Get(context.Background())
Sequential execution of steps:
// Create a chain workflow
workflow := workflows.NewChainWorkflow(store)
// Add steps to the workflow
workflow.AddStep(&workflows.Step{
ID: "step1",
Module: modules.NewPredict(signature1),
})
workflow.AddStep(&workflows.Step{
ID: "step2",
Module: modules.NewPredict(signature2),
})
// Execute the workflow
result, err := workflow.Execute(ctx, inputs)
Each workflow step can be configured with retry logic:
step := &workflows.Step{
ID: "retry_example",
Module: myModule,
RetryConfig: &workflows.RetryConfig{
MaxAttempts: 3,
BackoffMultiplier: 2.0,
InitialBackoff: time.Second,
},
Condition: func(state map[string]interface{}) bool {
return someCondition(state)
},
}
Flexible task decomposition and execution:
// Create an orchestrator with subtasks
orchestrator := agents.NewOrchestrator()
// Define and add subtasks
researchTask := agents.NewTask("research", researchModule)
summarizeTask := agents.NewTask("summarize", summarizeModule)
orchestrator.AddTask(researchTask)
orchestrator.AddTask(summarizeTask)
// Execute the orchestration
result, err := orchestrator.Execute(ctx, map[string]interface{}{
"topic": "Climate change impacts",
})
DSPy-Go supports multiple LLM providers with flexible configuration options:
// Using Anthropic Claude
llm, err := llms.NewAnthropicLLM("api-key", core.ModelAnthropicSonnet)
// Using Google Gemini
llm, err := llms.NewGeminiLLM("api-key", "gemini-pro")
// Using OpenAI (standard)
llm, err := llms.NewOpenAI(core.ModelOpenAIGPT4, "api-key")
// Using LiteLLM (OpenAI-compatible)
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithAPIKey("api-key"),
llms.WithOpenAIBaseURL("http://localhost:4000"))
// Using LocalAI (OpenAI-compatible)
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithAPIKey("api-key"),
llms.WithOpenAIBaseURL("http://localhost:8080"),
llms.WithOpenAIPath("/v1/chat/completions"))
// Using custom OpenAI-compatible API
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithAPIKey("custom-key"),
llms.WithOpenAIBaseURL("https://api.custom-provider.com"),
llms.WithHeader("Custom-Header", "value"),
llms.WithOpenAITimeout(30*time.Second))
// Using Ollama (local)
llm, err := llms.NewOllamaLLM("ollama:llama2")
// Using LlamaCPP (local)
llm, err := llms.NewLlamacppLLM("http://localhost:8080")
// Set as default LLM
core.SetDefaultLLM(llm)
// Or use with a specific module
myModule.SetLLM(llm)
DSPy-Go's OpenAI provider supports any OpenAI-compatible API through functional options, making it easy to work with various providers:
LiteLLM provides a unified interface to 100+ LLMs:
// Basic LiteLLM setup
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithAPIKey("your-api-key"),
llms.WithOpenAIBaseURL("http://localhost:4000"))
// LiteLLM with custom configuration
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithAPIKey("litellm-key"),
llms.WithOpenAIBaseURL("https://your-litellm-instance.com"),
llms.WithOpenAITimeout(60*time.Second),
llms.WithHeader("X-Custom-Header", "value"))
LocalAI for running local models:
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithOpenAIBaseURL("http://localhost:8080"),
llms.WithOpenAIPath("/v1/chat/completions"))
FastChat for serving local models:
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithOpenAIBaseURL("http://localhost:8000"),
llms.WithOpenAIPath("/v1/chat/completions"))
Configure for Azure OpenAI Service:
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithAPIKey("azure-api-key"),
llms.WithOpenAIBaseURL("https://your-resource.openai.azure.com"),
llms.WithOpenAIPath("/openai/deployments/your-deployment/chat/completions"),
llms.WithHeader("api-version", "2024-02-15-preview"))
Any API that follows the OpenAI chat completions format:
llm, err := llms.NewOpenAILLM(core.ModelOpenAIGPT4,
llms.WithAPIKey("custom-key"),
llms.WithOpenAIBaseURL("https://api.custom-provider.com"),
llms.WithOpenAIPath("/v1/chat/completions"),
llms.WithOpenAITimeout(30*time.Second),
llms.WithHeader("Authorization", "Bearer custom-token"),
llms.WithHeader("X-API-Version", "v1"))
DSPy-Go includes detailed tracing and structured logging for debugging and optimization:
// Enable detailed tracing
ctx = core.WithExecutionState(context.Background())
// Configure logging
logger := logging.NewLogger(logging.Config{
Severity: logging.DEBUG,
Outputs: []logging.Output{logging.NewConsoleOutput(true)},
})
logging.SetLogger(logger)
// After execution, inspect trace
executionState := core.GetExecutionState(ctx)
steps := executionState.GetSteps("moduleId")
for _, step := range steps {
fmt.Printf("Step: %s, Duration: %s\n", step.Name, step.Duration)
fmt.Printf("Prompt: %s\n", step.Prompt)
fmt.Printf("Response: %s\n", step.Response)
}
You can extend ReAct modules with custom tools:
// Define a custom tool
type WeatherTool struct{}
func (t *WeatherTool) GetName() string {
return "weather"
}
func (t *WeatherTool) GetDescription() string {
return "Get the current weather for a location"
}
func (t *WeatherTool) CanHandle(action string) bool {
return strings.HasPrefix(action, "weather(")
}
func (t *WeatherTool) Execute(ctx context.Context, action string) (string, error) {
// Parse location from action
location := parseLocation(action)
// Fetch weather data (implementation detail)
weather, err := fetchWeather(location)
if err != nil {
return "", err
}
return fmt.Sprintf("Weather in %s: %s, %d°C", location, weather.Condition, weather.Temperature), nil
}
// Use the custom tool with ReAct
registry := tools.NewInMemoryToolRegistry()
registry.Register(&WeatherTool{})
react := modules.NewReAct(signature, registry, 5)
DSPy-Go includes an intelligent tool management system that uses Bayesian inference for optimal tool selection:
import "github.com/XiaoConstantine/dspy-go/pkg/tools"
// Create intelligent tool registry
config := &tools.SmartToolRegistryConfig{
AutoDiscoveryEnabled: true, // Auto-discover from MCP servers
PerformanceTrackingEnabled: true, // Track tool performance metrics
FallbackEnabled: true, // Intelligent fallback selection
}
registry := tools.NewSmartToolRegistry(config)
// Register tools
registry.Register(mySearchTool)
registry.Register(myAnalysisTool)
// Intelligent tool selection based on intent
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)
Key Features:
DSPy-Go provides powerful capabilities for chaining and composing tools to build complex workflows:
Create sequential pipelines with data transformation and conditional execution:
import "github.com/XiaoConstantine/dspy-go/pkg/tools"
// Create a tool pipeline with fluent API
pipeline, err := tools.NewPipelineBuilder("data_processing", registry).
Step("data_extractor").
StepWithTransformer("data_validator", tools.TransformExtractField("result")).
ConditionalStep("data_enricher",
tools.ConditionExists("validation_result"),
tools.ConditionEquals("status", "validated")).
StepWithRetries("data_transformer", 3).
FailFast().
EnableCaching().
Build()
// Execute the pipeline
result, err := pipeline.Execute(ctx, map[string]interface{}{
"raw_data": "input data to process",
})
Transform data between pipeline steps:
// Extract specific fields
transformer := tools.TransformExtractField("important_field")
// Rename fields
transformer := tools.TransformRename(map[string]string{
"old_name": "new_name",
})
// Chain multiple transformations
transformer := tools.TransformChain(
tools.TransformRename(map[string]string{"status": "processing_status"}),
tools.TransformAddConstant(map[string]interface{}{"pipeline_id": "001"}),
tools.TransformFilter([]string{"result", "pipeline_id", "processing_status"}),
)
Automatic execution planning with parallel optimization:
// Create dependency graph
graph := tools.NewDependencyGraph()
// Define tool dependencies
graph.AddNode(&tools.DependencyNode{
ToolName: "data_extractor",
Dependencies: []string{},
Outputs: []string{"raw_data"},
Priority: 1,
})
graph.AddNode(&tools.DependencyNode{
ToolName: "data_validator",
Dependencies: []string{"data_extractor"},
Inputs: []string{"raw_data"},
Outputs: []string{"validated_data"},
Priority: 2,
})
// Create dependency-aware pipeline
depPipeline, err := tools.NewDependencyPipeline("smart_pipeline", registry, graph, options)
// Execute with automatic parallelization
result, err := depPipeline.ExecuteWithDependencies(ctx, input)
High-performance parallel tool execution with advanced scheduling:
// Create parallel executor
executor := tools.NewParallelExecutor(registry, 4) // 4 workers
// Define parallel tasks
tasks := []*tools.ParallelTask{
{
ID: "task1",
ToolName: "analyzer",
Input: data1,
Priority: 1,
},
{
ID: "task2",
ToolName: "processor",
Input: data2,
Priority: 2,
},
}
// Execute with priority scheduling
results, err := executor.ExecuteParallel(ctx, tasks, &tools.PriorityScheduler{})
// Or use fair share scheduling
results, err := executor.ExecuteParallel(ctx, tasks, tools.NewFairShareScheduler())
Create reusable composite tools by combining multiple tools:
// Define a composite tool
type CompositeTool struct {
name string
pipeline *tools.ToolPipeline
}
// Helper function to create composite tools
func NewCompositeTool(name string, registry core.ToolRegistry,
builder func(*tools.PipelineBuilder) *tools.PipelineBuilder) (*CompositeTool, error) {
pipeline, err := builder(tools.NewPipelineBuilder(name+"_pipeline", registry)).Build()
if err != nil {
return nil, err
}
return &CompositeTool{
name: name,
pipeline: pipeline,
}, nil
}
// Create a composite tool
textProcessor, err := NewCompositeTool("text_processor", registry,
func(builder *tools.PipelineBuilder) *tools.PipelineBuilder {
return builder.
Step("text_uppercase").
Step("text_reverse").
Step("text_length")
})
// Register and use like any other tool
registry.Register(textProcessor)
result, err := textProcessor.Execute(ctx, input)
// Use in other pipelines or compositions
complexPipeline, err := tools.NewPipelineBuilder("complex", registry).
Step("text_processor"). // Using our composite tool
Step("final_formatter").
Build()
Key Features:
DSPy-Go supports integration with MCP servers for accessing external tools and services:
import (
"github.com/XiaoConstantine/dspy-go/pkg/tools"
"github.com/XiaoConstantine/mcp-go/pkg/client"
)
// Connect to an MCP server
mcpClient, err := client.NewStdioClient("path/to/mcp-server")
if err != nil {
log.Fatal(err)
}
// Example 1: Use MCP tools with ReAct (requires InMemoryToolRegistry)
registry := tools.NewInMemoryToolRegistry()
err = tools.RegisterMCPTools(registry, mcpClient)
if err != nil {
log.Fatal(err)
}
react := modules.NewReAct(signature, registry, 5)
// Example 2: Use Smart Tool Registry for intelligent tool selection
smartRegistry := tools.NewSmartToolRegistry(&tools.SmartToolRegistryConfig{
PerformanceTrackingEnabled: true,
})
err = tools.RegisterMCPTools(smartRegistry, mcpClient)
if err != nil {
log.Fatal(err)
}
selectedTool, err := smartRegistry.SelectBest(ctx, "analyze financial data")
Process LLM outputs incrementally as they're generated:
// Create a streaming handler
handler := func(chunk string) {
fmt.Print(chunk)
}
// Enable streaming on the module
module.SetStreamingHandler(handler)
// Process with streaming enabled
result, err := module.Process(ctx, inputs)
DSPy-Go provides built-in support for downloading and managing common datasets:
import "github.com/XiaoConstantine/dspy-go/pkg/datasets"
// Automatically download and get path to GSM8K dataset
gsm8kPath, err := datasets.EnsureDataset("gsm8k")
if err != nil {
log.Fatal(err)
}
// Load GSM8K dataset
gsm8kDataset, err := datasets.LoadGSM8K(gsm8kPath)
if err != nil {
log.Fatal(err)
}
// Similarly for HotPotQA dataset
hotpotPath, err := datasets.EnsureDataset("hotpotqa")
if err != nil {
log.Fatal(err)
}
hotpotDataset, err := datasets.LoadHotPotQA(hotpotPath)
if err != nil {
log.Fatal(err)
}
// Use datasets with optimizers
optimizer := optimizers.NewBootstrapFewShot(gsm8kDataset, metricFunc)
optimizedModule, err := optimizer.Optimize(ctx, module)
DSPy-Go includes a comprehensive compatibility testing framework to ensure that optimizer implementations match the behavior of Python DSPy:
cd compatibility_test
# Test all optimizers (BootstrapFewShot, MIPRO, SIMBA, GEPA)
./run_experiment.sh
# Test specific optimizer
./run_experiment.sh --optimizer gepa --dataset-size 10
# Manual execution
python dspy_comparison.py --optimizer gepa
go run go_comparison.go --optimizer gepa
python compare_results.py
The framework tests:
Results are saved as JSON files with detailed compatibility analysis and recommendations.
DSPy-CLI: Interactive command-line tool for exploring optimizers without writing code. Perfect for getting started, testing optimizers, and rapid experimentation.
cd cmd/dspy-cli && go build -o dspy-cli
./dspy-cli try mipro --dataset gsm8k --max-examples 5 --verbose
Check the examples directory for complete implementations:
# Run basic Smart Tool Registry example
cd examples/smart_tool_registry
go run main.go
# Run advanced features demonstration
# Edit advanced_example.go to uncomment main() function
go run advanced_example.go
The Smart Tool Registry examples demonstrate:
# Run tool chaining examples
cd examples/tool_chaining
go run main.go
# Run tool composition examples
cd examples/tool_composition
go run main.go
The Tool Chaining and Composition examples demonstrate:
Tool Chaining:
Tool Composition:
# Run multimodal example (requires GEMINI_API_KEY)
cd examples/multimodal
export GEMINI_API_KEY="your-api-key-here"
go run main.go
The Multimodal Processing example demonstrates:
For more detailed documentation:
DSPy-Go is released under the MIT License. See the LICENSE file for details.
FAQs
Unknown package
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
Socket researchers identified a malicious Chrome extension that manipulates Raydium swaps to inject an undisclosed SOL transfer, quietly routing fees to an attacker wallet.
Research
/Security News
Another wave of Shai-Hulud campaign has hit npm with more than 500 packages and 700+ versions affected.
Product
Add real-time Socket webhook events to your workflows to automatically receive software supply chain alert changes in real time.