repo stringlengths 6 47 | file_url stringlengths 77 269 | file_path stringlengths 5 186 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-07 08:35:43 2026-01-07 08:55:24 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/memory_strategies/main.go | examples/memory_strategies/main.go | package main
import (
"context"
"fmt"
"time"
"github.com/smallnest/langgraphgo/memory"
)
func main() {
ctx := context.Background()
fmt.Println("=== Memory Strategies Examples ===")
// 1. Sequential Memory
fmt.Println("1. Sequential Memory (Keep-It-All)")
fmt.Println(" - Stores all messages without limit")
demoSequentialMemory(ctx)
// 2. Sliding Window Memory
fmt.Println("\n2. Sliding Window Memory")
fmt.Println(" - Keeps only recent N messages")
demoSlidingWindowMemory(ctx)
// 3. Buffer Memory
fmt.Println("\n3. Buffer Memory")
fmt.Println(" - Flexible limits by messages or tokens")
demoBufferMemory(ctx)
// 4. Summarization Memory
fmt.Println("\n4. Summarization Memory")
fmt.Println(" - Summarizes old messages, keeps recent ones")
demoSummarizationMemory(ctx)
// 5. Retrieval Memory
fmt.Println("\n5. Retrieval Memory")
fmt.Println(" - Retrieves most relevant messages using embeddings")
demoRetrievalMemory(ctx)
// 6. Hierarchical Memory
fmt.Println("\n6. Hierarchical Memory")
fmt.Println(" - Separates important and recent messages")
demoHierarchicalMemory(ctx)
// 7. Graph-Based Memory
fmt.Println("\n7. Graph-Based Memory")
fmt.Println(" - Tracks relationships between messages")
demoGraphBasedMemory(ctx)
// 8. Compression Memory
fmt.Println("\n8. Compression Memory")
fmt.Println(" - Compresses and consolidates old messages")
demoCompressionMemory(ctx)
// 9. OS-Like Memory
fmt.Println("\n9. OS-Like Memory")
fmt.Println(" - Multi-tier memory with paging and eviction")
demoOSLikeMemory(ctx)
}
func demoSequentialMemory(ctx context.Context) {
mem := memory.NewSequentialMemory()
// Add some messages
messages := []struct {
role string
content string
}{
{"user", "Hello!"},
{"assistant", "Hi there! How can I help you?"},
{"user", "What's the weather like?"},
{"assistant", "I don't have real-time weather data, but I can help you find it!"},
}
for _, msg := range messages {
mem.AddMessage(ctx, memory.NewMessage(msg.role, msg.content))
}
// Get all context
result, _ := mem.GetContext(ctx, "")
stats, _ := mem.GetStats(ctx)
fmt.Printf(" Total messages: %d, Active messages: %d\n", stats.TotalMessages, stats.ActiveMessages)
fmt.Printf(" Latest message: %s\n", result[len(result)-1].Content)
}
func demoSlidingWindowMemory(ctx context.Context) {
// Keep only last 3 messages
mem := memory.NewSlidingWindowMemory(3)
// Add 5 messages
for i := 1; i <= 5; i++ {
mem.AddMessage(ctx, memory.NewMessage("user", fmt.Sprintf("Message %d", i)))
}
result, _ := mem.GetContext(ctx, "")
stats, _ := mem.GetStats(ctx)
fmt.Printf(" Window size: 3, Total added: 5, Kept: %d\n", stats.TotalMessages)
fmt.Printf(" Messages in window: ")
for i, msg := range result {
if i > 0 {
fmt.Print(", ")
}
fmt.Printf("\"%s\"", msg.Content)
}
fmt.Println()
}
func demoBufferMemory(ctx context.Context) {
// Limit by message count
mem := memory.NewBufferMemory(&memory.BufferConfig{
MaxMessages: 3,
MaxTokens: 1000,
})
// Add messages
for i := 1; i <= 5; i++ {
mem.AddMessage(ctx, memory.NewMessage("user", fmt.Sprintf("Buffer message %d", i)))
}
result, _ := mem.GetContext(ctx, "")
stats, _ := mem.GetStats(ctx)
fmt.Printf(" Max messages: 3, Added: 5, Kept: %d\n", len(result))
fmt.Printf(" Total tokens: %d\n", stats.TotalTokens)
}
func demoSummarizationMemory(ctx context.Context) {
mem := memory.NewSummarizationMemory(&memory.SummarizationConfig{
RecentWindowSize: 2, // Keep last 2 messages
SummarizeAfter: 4, // Summarize after 4 messages
})
// Add messages to trigger summarization
topics := []string{"weather", "sports", "news", "tech", "music"}
for _, topic := range topics {
mem.AddMessage(ctx, memory.NewMessage("user", fmt.Sprintf("Tell me about %s", topic)))
mem.AddMessage(ctx, memory.NewMessage("assistant", fmt.Sprintf("Here's info about %s...", topic)))
}
result, _ := mem.GetContext(ctx, "")
stats, _ := mem.GetStats(ctx)
fmt.Printf(" Total messages: %d, Active (recent + summary): %d\n", stats.TotalMessages, stats.ActiveMessages)
// Check if summary was created
hasSummary := false
for _, msg := range result {
if msg.Role == "system" {
hasSummary = true
break
}
}
fmt.Printf(" Summary created: %v\n", hasSummary)
}
func demoRetrievalMemory(ctx context.Context) {
mem := memory.NewRetrievalMemory(&memory.RetrievalConfig{
TopK: 2, // Retrieve top 2 relevant messages
})
// Add messages about different topics
messages := []struct {
content string
}{
{"Python is a programming language"},
{"The weather is sunny today"},
{"Go is great for concurrency"},
{"It might rain tomorrow"},
{"JavaScript runs in browsers"},
}
for _, msg := range messages {
mem.AddMessage(ctx, memory.NewMessage("user", msg.content))
}
// Query for programming-related content
result, _ := mem.GetContext(ctx, "programming languages")
stats, _ := mem.GetStats(ctx)
fmt.Printf(" Total stored: %d, Query: \"programming languages\", Retrieved: %d\n",
stats.TotalMessages, len(result))
if len(result) > 0 {
fmt.Printf(" Most relevant: \"%s\"\n", result[0].Content)
}
}
func demoHierarchicalMemory(ctx context.Context) {
mem := memory.NewHierarchicalMemory(&memory.HierarchicalConfig{
RecentLimit: 2,
ImportantLimit: 2,
})
// Add messages with varying importance
messages := []struct {
content string
importance float64
}{
{"Regular message 1", 0.3},
{"IMPORTANT: Remember this key fact", 0.9},
{"Regular message 2", 0.4},
{"CRITICAL: System alert", 0.95},
{"Regular message 3", 0.3},
}
for _, msg := range messages {
m := memory.NewMessage("user", msg.content)
if msg.importance > 0.7 {
m.Metadata["importance"] = msg.importance
}
mem.AddMessage(ctx, m)
}
result, _ := mem.GetContext(ctx, "")
stats, _ := mem.GetStats(ctx)
fmt.Printf(" Total: %d, Active (important + recent): %d\n", stats.TotalMessages, len(result))
// Count important messages in result
importantCount := 0
for _, msg := range result {
if imp, ok := msg.Metadata["importance"].(float64); ok && imp > 0.7 {
importantCount++
}
}
fmt.Printf(" Important messages in context: %d\n", importantCount)
}
func demoGraphBasedMemory(ctx context.Context) {
mem := memory.NewGraphBasedMemory(&memory.GraphConfig{
TopK: 3,
})
// Add related messages
messages := []string{
"What's the price of the product?",
"The price is $99",
"Tell me about the features",
"What's the price again?",
"Does it have a warranty?",
}
for _, content := range messages {
mem.AddMessage(ctx, memory.NewMessage("user", content))
}
// Query for price-related messages
result, _ := mem.GetContext(ctx, "price information")
stats, _ := mem.GetStats(ctx)
fmt.Printf(" Total: %d, Query: \"price information\", Retrieved: %d\n",
stats.TotalMessages, len(result))
relations := mem.GetRelationships()
fmt.Printf(" Topic relationships tracked: %d\n", len(relations))
}
func demoCompressionMemory(ctx context.Context) {
mem := memory.NewCompressionMemory(&memory.CompressionConfig{
CompressionTrigger: 3, // Compress after 3 messages
})
// Add messages to trigger compression
for i := 1; i <= 7; i++ {
mem.AddMessage(ctx, memory.NewMessage("user", fmt.Sprintf("Message %d with some content", i)))
}
result, _ := mem.GetContext(ctx, "")
stats, _ := mem.GetStats(ctx)
fmt.Printf(" Total original: %d, Active (blocks + recent): %d\n",
stats.TotalMessages, stats.ActiveMessages)
fmt.Printf(" Compression rate: %.2f\n", stats.CompressionRate)
// Check for compressed blocks
hasCompressed := false
for _, msg := range result {
if msg.Role == "system" {
hasCompressed = true
break
}
}
fmt.Printf(" Compressed blocks: %v\n", hasCompressed)
}
func demoOSLikeMemory(ctx context.Context) {
mem := memory.NewOSLikeMemory(&memory.OSLikeConfig{
ActiveLimit: 2, // 2 pages in active memory
CacheLimit: 3, // 3 pages in cache
AccessWindow: time.Minute * 5,
})
// Add messages over time
for i := 1; i <= 15; i++ {
mem.AddMessage(ctx, memory.NewMessage("user", fmt.Sprintf("Message %d", i)))
}
result, _ := mem.GetContext(ctx, "")
stats, _ := mem.GetStats(ctx)
info := mem.GetMemoryInfo()
fmt.Printf(" Total: %d, Active: %d\n", stats.TotalMessages, stats.ActiveMessages)
fmt.Printf(" Memory tiers - Active: %d, Cache: %d, Archive: %d pages\n",
info["active_pages"].(int),
info["cached_pages"].(int),
info["archived_pages"].(int))
fmt.Printf(" Retrieved from active memory: %d messages\n", len(result))
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/ptc_simple/main.go | examples/ptc_simple/main.go | package main
import (
"context"
"fmt"
"log"
"github.com/smallnest/langgraphgo/ptc"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
"github.com/tmc/langchaingo/tools"
)
// CalculatorTool performs arithmetic operations
type CalculatorTool struct{}
func (t CalculatorTool) Name() string {
return "calculator"
}
func (t CalculatorTool) Description() string {
return "Performs arithmetic calculations. Input should be a mathematical expression as a string (e.g., '2 + 2', '10 * 5')."
}
func (t CalculatorTool) Call(ctx context.Context, input string) (string, error) {
// Simple calculator implementation
// In a real implementation, use a proper expression parser
return fmt.Sprintf("Result of '%s' would be calculated here", input), nil
}
// WeatherTool gets weather information
type WeatherTool struct{}
func (t WeatherTool) Name() string {
return "get_weather"
}
func (t WeatherTool) Description() string {
return "Gets current weather for a location. Input should be the city name."
}
func (t WeatherTool) Call(ctx context.Context, input string) (string, error) {
// Mock weather data
return fmt.Sprintf("Weather in %s: Sunny, 72°F", input), nil
}
func main() {
fmt.Println("=== Simple PTC Example ===\n")
// Create model (supports any LLM that implements llms.Model)
model, err := openai.New()
if err != nil {
log.Fatalf("Failed to create model: %v", err)
}
// Define tools
toolList := []tools.Tool{
CalculatorTool{},
WeatherTool{},
}
// Create PTC agent
agent, err := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
Model: model,
Tools: toolList,
Language: ptc.LanguagePython, // or ptc.LanguageGo
MaxIterations: 5,
})
if err != nil {
log.Fatalf("Failed to create agent: %v", err)
}
// Run a query
query := "What's the weather in San Francisco and New York? Also calculate 125 * 8."
fmt.Printf("Query: %s\n\n", query)
result, err := agent.Invoke(context.Background(), map[string]any{
"messages": []llms.MessageContent{
{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{llms.TextPart(query)},
},
},
})
if err != nil {
log.Fatalf("Error: %v", err)
}
// Print result
messages := result["messages"].([]llms.MessageContent)
lastMsg := messages[len(messages)-1]
fmt.Println("Answer:")
for _, part := range lastMsg.Parts {
if textPart, ok := part.(llms.TextContent); ok {
fmt.Println(textPart.Text)
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/complex_parallel_execution/main.go | examples/complex_parallel_execution/main.go | package main
import (
"context"
"fmt"
"log"
"time"
"github.com/smallnest/langgraphgo/graph"
)
func main() {
// Create a new state graph
g := graph.NewStateGraph[map[string]any]()
// Define Schema
// We use a map schema where "results" is a list that accumulates values
// and "branch_status" tracks which branches have completed
schema := graph.NewMapSchema()
schema.RegisterReducer("results", graph.AppendReducer)
g.SetSchema(schema)
// Define Nodes
g.AddNode("start", "start", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("=== Complex Parallel Execution Start ===")
fmt.Println("[Start] Initiating fan-out to multiple branches...")
return map[string]any{
"timestamp": time.Now().Format("15:04:05.000"),
},
nil
})
// ==== Short Branch (1 node) ====
g.AddNode("short_branch", "short_branch", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("\n[Short Branch] Starting execution...")
time.Sleep(100 * time.Millisecond)
fmt.Println("[Short Branch] ✓ Completed (fast path)")
return map[string]any{
"results": []string{"Short branch result"},
},
nil
})
// ==== Medium Branch (2 nodes) ====
g.AddNode("medium_branch_1", "medium_branch_1", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("\n[Medium Branch - Step 1/2] Processing...")
time.Sleep(150 * time.Millisecond)
fmt.Println("[Medium Branch - Step 1/2] ✓ Completed")
return map[string]any{
"medium_temp": "intermediate_data",
},
nil
})
g.AddNode("medium_branch_2", "medium_branch_2", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Medium Branch - Step 2/2] Processing...")
time.Sleep(150 * time.Millisecond)
fmt.Println("[Medium Branch - Step 2/2] ✓ Completed")
return map[string]any{
"results": []string{"Medium branch result (2 steps)"},
},
nil
})
// ==== Long Branch (3 nodes) ====
g.AddNode("long_branch_1", "long_branch_1", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("\n[Long Branch - Step 1/3] Initial processing...")
time.Sleep(200 * time.Millisecond)
fmt.Println("[Long Branch - Step 1/3] ✓ Completed")
return map[string]any{
"long_temp_1": "data_from_step1",
},
nil
})
g.AddNode("long_branch_2", "long_branch_2", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Long Branch - Step 2/3] Advanced processing...")
time.Sleep(200 * time.Millisecond)
fmt.Println("[Long Branch - Step 2/3] ✓ Completed")
return map[string]any{
"long_temp_2": "data_from_step2",
},
nil
})
g.AddNode("long_branch_3", "long_branch_3", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Long Branch - Step 3/3] Final processing...")
time.Sleep(200 * time.Millisecond)
fmt.Println("[Long Branch - Step 3/3] ✓ Completed")
return map[string]any{
"results": []string{"Long branch result (3 steps)"},
},
nil
})
// ==== Aggregator Node ====
g.AddNode("aggregator", "aggregator", func(ctx context.Context, state map[string]any) (map[string]any, error) {
// results is likely []any due to AppendReducer, we need to assert items
// Or if we used []string in previous nodes, it might be []any with string elements?
// AppendReducer in graph/schema.go returns []any if current is nil or appends to existing slice.
// Since we init with empty slice (untyped? no, we init with []string in map[string]any), AppendReducer should keep it as []string if possible?
// Wait, NewMapSchema RegisterReducer("results", AppendReducer).
// AppendReducer implementation:
// if current is []string, and new is []string, it returns []string.
// Let's check state["results"].
resultsSlice, ok := state["results"].([]string)
if !ok {
// Try []any
if resultsAny, ok := state["results"].([]any); ok {
resultsSlice = make([]string, len(resultsAny))
for i, v := range resultsAny {
resultsSlice[i] = fmt.Sprint(v)
}
}
}
fmt.Println("\n=== Aggregation Point ===")
fmt.Printf("[Aggregator] All branches completed!\n")
fmt.Printf("[Aggregator] Collected %d results:\n", len(resultsSlice))
for i, result := range resultsSlice {
fmt.Printf(" %d. %s\n", i+1, result)
}
return map[string]any{
"status": "all_branches_completed",
"total_results": len(resultsSlice),
"final_message": "Complex parallel execution finished successfully",
},
nil
})
// ==== Define Graph Structure ====
g.SetEntryPoint("start")
// Fan-out: Start -> All branch entry points
g.AddEdge("start", "short_branch")
g.AddEdge("start", "medium_branch_1")
g.AddEdge("start", "long_branch_1")
// Medium branch internal flow
g.AddEdge("medium_branch_1", "medium_branch_2")
// Long branch internal flow
g.AddEdge("long_branch_1", "long_branch_2")
g.AddEdge("long_branch_2", "long_branch_3")
// Fan-in: All branch endpoints -> Aggregator
g.AddEdge("short_branch", "aggregator")
g.AddEdge("medium_branch_2", "aggregator")
g.AddEdge("long_branch_3", "aggregator")
g.AddEdge("aggregator", graph.END)
// Compile
runnable, err := g.Compile()
if err != nil {
log.Fatal(err)
}
// Execute
initialState := map[string]any{
"results": []string{},
}
fmt.Println("=== Complex Parallel Execution Example ===")
fmt.Println("Graph Structure:")
fmt.Println(" start")
fmt.Println(" ├─> short_branch (1 step) ────────────┐")
fmt.Println(" ├─> medium_branch_1 -> medium_branch_2 ├─> aggregator -> END")
fmt.Println(" └─> long_branch_1 -> long_branch_2 -> long_branch_3 ─┘")
fmt.Println()
startTime := time.Now()
res, err := runnable.Invoke(context.Background(), initialState)
if err != nil {
log.Fatal(err)
}
elapsed := time.Since(startTime)
fmt.Println("\n=== Execution Complete ===")
fmt.Printf("Total execution time: %v\n", elapsed)
fmt.Printf("Final State: %v\n", res)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/rag_with_embeddings/main.go | examples/rag_with_embeddings/main.go | package main
import (
"context"
"fmt"
"log"
"github.com/smallnest/langgraphgo/graph"
"github.com/smallnest/langgraphgo/rag"
"github.com/smallnest/langgraphgo/rag/retriever"
"github.com/smallnest/langgraphgo/rag/store"
"github.com/tmc/langchaingo/llms/openai"
)
func main() {
ctx := context.Background()
llm, err := openai.New()
if err != nil {
log.Fatalf("Failed to create LLM: %v", err)
}
documents := []rag.Document{
{Content: "Go is a statically typed, compiled programming language."},
{Content: "Python is an interpreted, high-level and general-purpose programming language."},
}
embedder := store.NewMockEmbedder(128)
vectorStore := store.NewInMemoryVectorStore(embedder)
texts := make([]string, len(documents))
for i, doc := range documents {
texts[i] = doc.Content
}
embeddings, _ := embedder.EmbedDocuments(ctx, texts)
vectorStore.AddBatch(ctx, documents, embeddings)
retriever := retriever.NewVectorStoreRetriever(vectorStore, embedder, 2)
config := rag.DefaultPipelineConfig()
config.Retriever = retriever
config.LLM = llm
pipeline := rag.NewRAGPipeline(config)
err = pipeline.BuildBasicRAG()
if err != nil {
log.Fatalf("Failed to build RAG pipeline: %v", err)
}
runnable, err := pipeline.Compile()
if err != nil {
log.Fatalf("Failed to compile pipeline: %v", err)
}
exporter := graph.GetGraphForRunnable(runnable)
fmt.Println(exporter.DrawASCII())
query := "What is Go?"
fmt.Printf("\nQuery: %s\n", query)
result, err := runnable.Invoke(ctx, map[string]any{
"query": query,
})
if err != nil {
log.Fatalf("Failed to process query: %v", err)
}
if answer, ok := result["answer"].(string); ok {
fmt.Printf("Answer: %s\n", answer)
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/rag_falkordb_simple/main.go | examples/rag_falkordb_simple/main.go | package main
import (
"context"
"fmt"
"log"
"strings"
"github.com/redis/go-redis/v9"
"github.com/smallnest/langgraphgo/rag"
"github.com/smallnest/langgraphgo/rag/store"
)
func main() {
ctx := context.Background()
// Create FalkorDB knowledge graph
fmt.Println("Initializing FalkorDB knowledge graph...")
falkorDBConnStr := "falkordb://localhost:6379/simple_rag_graph"
kg, err := store.NewFalkorDBGraph(falkorDBConnStr)
if err != nil {
log.Fatalf("Failed to create FalkorDB knowledge graph: %v", err)
}
// Close the connection when done (type assert to access Close method)
defer func() {
if falkorDB, ok := kg.(*store.FalkorDBGraph); ok {
falkorDB.Close()
}
}()
// Add entities manually to the knowledge graph (simplified approach)
fmt.Println("Adding entities and relationships to knowledge graph...")
// Add entities manually to the knowledge graph
entities := []*rag.Entity{
{
ID: "john_smith",
Name: "John Smith",
Type: "PERSON",
Properties: map[string]any{
"role": "senior software engineer",
"specialty": "machine learning and artificial intelligence",
"company": "Google",
},
},
{
ID: "sarah_johnson",
Name: "Sarah Johnson",
Type: "PERSON",
Properties: map[string]any{
"role": "CEO",
"company": "TechStart Inc.",
},
},
{
ID: "google",
Name: "Google",
Type: "ORGANIZATION",
Properties: map[string]any{
"industry": "technology",
"location": "Mountain View, California",
},
},
{
ID: "techstart",
Name: "TechStart Inc.",
Type: "ORGANIZATION",
Properties: map[string]any{
"specialty": "blockchain technology",
"location": "San Francisco",
},
},
{
ID: "python",
Name: "Python",
Type: "TECHNOLOGY",
Properties: map[string]any{
"type": "programming language",
"uses": "machine learning, web development, data science",
"libraries": "TensorFlow, PyTorch",
},
},
{
ID: "machine_learning",
Name: "Machine Learning",
Type: "CONCEPT",
Properties: map[string]any{
"category": "subset of artificial intelligence",
"description": "enables computers to learn from data",
"algorithms": "neural networks, decision trees",
},
},
}
// Add entities manually to the knowledge graph
fmt.Println("Adding entities...")
for _, entity := range entities {
err := kg.AddEntity(ctx, entity)
if err != nil {
log.Printf("Failed to add entity %s: %v", entity.ID, err)
} else {
fmt.Printf(" ✓ Added entity: %s (%s)\n", entity.Name, entity.Type)
}
}
// Add relationships manually to the knowledge graph
fmt.Println("\nAdding relationships...")
relationships := []*rag.Relationship{
{
ID: "john_works_at_google",
Source: "john_smith",
Target: "google",
Type: "WORKS_AT",
},
{
ID: "sarah_ceo_of_techstart",
Source: "sarah_johnson",
Target: "techstart",
Type: "CEO_OF",
},
{
ID: "john_specializes_ml",
Source: "john_smith",
Target: "machine_learning",
Type: "SPECIALIZES_IN",
},
{
ID: "python_used_for_ml",
Source: "python",
Target: "machine_learning",
Type: "USED_FOR",
},
}
for _, rel := range relationships {
err := kg.AddRelationship(ctx, rel)
if err != nil {
log.Printf("Failed to add relationship %s: %v", rel.ID, err)
} else {
fmt.Printf(" ✓ Added relationship: %s -> %s (%s)\n", rel.Source, rel.Target, rel.Type)
}
}
fmt.Println("\nKnowledge graph populated successfully!\n")
// Use a custom implementation for better querying
fmt.Println("=== Fixed Graph Query Examples ===\n")
// Create a Redis client for direct queries
client := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
defer client.Close()
// Query examples using direct Redis commands
queryExamples := []struct {
description string
cypherQuery string
}{
{
description: "Find all PERSON entities",
cypherQuery: "MATCH (n:PERSON) RETURN n.id, n.name, n.role, n.company",
},
{
description: "Find all ORGANIZATION entities",
cypherQuery: "MATCH (n:ORGANIZATION) RETURN n.id, n.name, n.industry",
},
{
description: "Find all TECHNOLOGY entities",
cypherQuery: "MATCH (n:TECHNOLOGY) RETURN n.id, n.name, n.type, n.uses",
},
{
description: "Find all CONCEPT entities",
cypherQuery: "MATCH (n:CONCEPT) RETURN n.id, n.name, n.description",
},
}
for i, example := range queryExamples {
fmt.Printf("=== Query %d ===\n", i+1)
fmt.Printf("Description: %s\n\n", example.description)
// Execute query
result, err := client.Do(ctx, "GRAPH.QUERY", "simple_rag_graph", example.cypherQuery).Result()
if err != nil {
log.Printf("Failed to execute query: %v", err)
continue
}
// Parse the result (simplified parsing for non-compact mode)
if r, ok := result.([]interface{}); ok && len(r) > 1 {
if rows, ok := r[1].([]interface{}); ok && len(rows) > 0 {
fmt.Printf("Results:\n")
for j, row := range rows {
if rowArr, ok := row.([]interface{}); ok {
fmt.Printf(" [%d] ", j+1)
for k, item := range rowArr {
if str, ok := item.(string); ok {
fmt.Printf("%s", str)
if k < len(rowArr)-1 {
fmt.Printf(", ")
}
}
}
fmt.Println()
}
}
} else {
fmt.Println(" No results found")
}
}
fmt.Println(strings.Repeat("-", 60))
}
// Demonstrate relationship queries
fmt.Println("\n=== Relationship Queries ===\n")
relationshipQueries := []struct {
description string
cypherQuery string
}{
{
description: "Find all relationships",
cypherQuery: "MATCH (a)-[r]->(b) RETURN a.name, type(r), b.name",
},
{
description: "Find who works where",
cypherQuery: "MATCH (p:PERSON)-[r:WORKS_AT]->(o:ORGANIZATION) RETURN p.name, r, o.name",
},
{
description: "Find what John Smith specializes in",
cypherQuery: "MATCH (p {name: 'John Smith'})-[r:SPECIALIZES_IN]->(c) RETURN p.name, type(r), c.name",
},
}
for i, example := range relationshipQueries {
fmt.Printf("=== Relationship Query %d ===\n", i+1)
fmt.Printf("Description: %s\n\n", example.description)
result, err := client.Do(ctx, "GRAPH.QUERY", "simple_rag_graph", example.cypherQuery).Result()
if err != nil {
log.Printf("Failed to execute relationship query: %v", err)
continue
}
if r, ok := result.([]interface{}); ok && len(r) > 1 {
if rows, ok := r[1].([]interface{}); ok && len(rows) > 0 {
fmt.Printf("Results:\n")
for j, row := range rows {
if rowArr, ok := row.([]interface{}); ok {
fmt.Printf(" [%d] ", j+1)
for k, item := range rowArr {
if str, ok := item.(string); ok {
fmt.Printf("%s", str)
if k < len(rowArr)-1 {
fmt.Printf(", ")
}
}
}
fmt.Println()
}
}
} else {
fmt.Println(" No results found")
}
}
fmt.Println(strings.Repeat("-", 60))
}
// Show statistics
fmt.Println("\n=== Knowledge Graph Statistics ===\n")
statsQueries := []struct {
name string
query string
}{
{"Total nodes", "MATCH (n) RETURN count(n) as count"},
{"Total relationships", "MATCH ()-[r]->() RETURN count(r) as count"},
{"Person count", "MATCH (p:PERSON) RETURN count(p) as count"},
{"Organization count", "MATCH (o:ORGANIZATION) RETURN count(o) as count"},
}
for _, stat := range statsQueries {
result, err := client.Do(ctx, "GRAPH.QUERY", "simple_rag_graph", stat.query).Result()
if err != nil {
log.Printf("Failed to get %s: %v", stat.name, err)
continue
}
if r, ok := result.([]interface{}); ok && len(r) > 1 {
if rows, ok := r[1].([]interface{}); ok && len(rows) > 0 {
if row, ok := rows[0].([]interface{}); ok && len(row) > 0 {
if count, ok := row[0].(int64); ok {
fmt.Printf("%s: %d\n", stat.name, count)
}
}
}
}
}
fmt.Println("\n=== Example Complete ===")
fmt.Println("This fixed example demonstrates:")
fmt.Println("✅ Proper entity and relationship storage")
fmt.Println("✅ Correct data retrieval and display")
fmt.Println("✅ Working relationship queries")
fmt.Println("✅ Knowledge graph statistics")
fmt.Println("✅ Ready for integration with RAG applications")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/chat_agent_dynamic_tools/main.go | examples/chat_agent_dynamic_tools/main.go | package main
import (
"context"
"fmt"
"log"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
"github.com/tmc/langchaingo/tools"
)
// SimpleMockModel is a simple mock model for demonstration
type SimpleMockModel struct {
turnCount int
}
func (m *SimpleMockModel) GenerateContent(ctx context.Context, messages []llms.MessageContent, options ...llms.CallOption) (*llms.ContentResponse, error) {
m.turnCount++
// Extract tool information from options
hasCalculator := false
hasWeather := false
// In a real scenario, we would inspect the options to see what tools are available
_ = options // Suppress unused variable warning
// Generate response based on turn
var response string
switch m.turnCount {
case 1:
response = "Hello! I can help you with various tasks. What would you like to do?"
case 2:
if hasCalculator {
response = "I can now perform calculations! The result is 4."
} else {
response = "I now have access to a calculator tool. What calculation would you like me to perform?"
}
case 3:
if hasWeather {
response = "I now have access to weather tools! The weather in San Francisco is sunny, 72°F."
} else {
response = "I now have access to a weather tool. Which city's weather would you like to know?"
}
case 4:
response = "I no longer have access to the calculator, but I still have the weather tool available."
default:
response = fmt.Sprintf("I'm ready to help! (Turn %d)", m.turnCount)
}
return &llms.ContentResponse{
Choices: []*llms.ContentChoice{
{Content: response},
},
}, nil
}
func (m *SimpleMockModel) Call(ctx context.Context, prompt string, options ...llms.CallOption) (string, error) {
return "", nil
}
// CalculatorTool is a simple calculator tool
type CalculatorTool struct{}
func (ct *CalculatorTool) Name() string {
return "calculator"
}
func (ct *CalculatorTool) Description() string {
return "Performs basic arithmetic calculations"
}
func (ct *CalculatorTool) Call(ctx context.Context, input string) (string, error) {
return fmt.Sprintf("Calculated: %s = 4", input), nil
}
// WeatherTool is a simple weather tool
type WeatherTool struct{}
func (wt *WeatherTool) Name() string {
return "weather"
}
func (wt *WeatherTool) Description() string {
return "Gets current weather for a city"
}
func (wt *WeatherTool) Call(ctx context.Context, input string) (string, error) {
return fmt.Sprintf("Weather in %s: Sunny, 72°F", input), nil
}
func main() {
fmt.Println("=== ChatAgent Dynamic Tools Demo ===")
fmt.Println("This example demonstrates how to add and remove tools dynamically during a conversation.")
fmt.Println()
llm, err := openai.New()
if err != nil {
log.Fatal(err)
}
// Create ChatAgent with no initial tools
agent, err := prebuilt.NewChatAgent(llm, nil)
if err != nil {
log.Fatalf("Failed to create ChatAgent: %v", err)
}
ctx := context.Background()
// Display session ID
fmt.Printf("Session ID: %s\n\n", agent.ThreadID())
// Turn 1: Initial chat with no tools
fmt.Println("--- Turn 1: No tools available ---")
fmt.Printf("Available tools: %d\n", len(agent.GetTools()))
fmt.Println("User: Hello!")
resp1, err := agent.Chat(ctx, "Hello!")
if err != nil {
log.Fatalf("Chat error: %v", err)
}
fmt.Printf("Agent: %s\n\n", resp1)
// Turn 2: Add calculator tool
fmt.Println("--- Turn 2: Adding calculator tool ---")
calcTool := &CalculatorTool{}
agent.AddTool(calcTool)
fmt.Printf("Available tools: %d (%s)\n", len(agent.GetTools()), agent.GetTools()[0].Name())
fmt.Println("User: Calculate 2 + 2")
resp2, err := agent.Chat(ctx, "Calculate 2 + 2")
if err != nil {
log.Fatalf("Chat error: %v", err)
}
fmt.Printf("Agent: %s\n\n", resp2)
// Turn 3: Add weather tool
fmt.Println("--- Turn 3: Adding weather tool ---")
weatherTool := &WeatherTool{}
agent.AddTool(weatherTool)
toolNames := []string{}
for _, t := range agent.GetTools() {
toolNames = append(toolNames, t.Name())
}
fmt.Printf("Available tools: %d (%v)\n", len(agent.GetTools()), toolNames)
fmt.Println("User: What's the weather in San Francisco?")
resp3, err := agent.Chat(ctx, "What's the weather in San Francisco?")
if err != nil {
log.Fatalf("Chat error: %v", err)
}
fmt.Printf("Agent: %s\n\n", resp3)
// Turn 4: Remove calculator tool
fmt.Println("--- Turn 4: Removing calculator tool ---")
removed := agent.RemoveTool("calculator")
if removed {
fmt.Println("Calculator tool removed successfully")
}
toolNames = []string{}
for _, t := range agent.GetTools() {
toolNames = append(toolNames, t.Name())
}
fmt.Printf("Available tools: %d (%v)\n", len(agent.GetTools()), toolNames)
fmt.Println("User: What tools do you have now?")
resp4, err := agent.Chat(ctx, "What tools do you have now?")
if err != nil {
log.Fatalf("Chat error: %v", err)
}
fmt.Printf("Agent: %s\n\n", resp4)
// Demonstration of other tool management methods
fmt.Println("--- Other Tool Management Features ---")
// SetTools - replace all tools at once
newTool1 := &CalculatorTool{}
newTool2 := &WeatherTool{}
agent.SetTools([]tools.Tool{newTool1, newTool2})
fmt.Printf("After SetTools: %d tools\n", len(agent.GetTools()))
// ClearTools - remove all tools
agent.ClearTools()
fmt.Printf("After ClearTools: %d tools\n", len(agent.GetTools()))
fmt.Println("\n=== Demo Complete ===")
fmt.Println("\nKey Features Demonstrated:")
fmt.Println("1. AddTool() - Add tools dynamically during conversation")
fmt.Println("2. RemoveTool() - Remove specific tools by name")
fmt.Println("3. GetTools() - Query currently available tools")
fmt.Println("4. SetTools() - Replace all tools at once")
fmt.Println("5. ClearTools() - Remove all dynamic tools")
fmt.Println("\nThe agent can adapt its capabilities on-the-fly based on context!")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/memory_chatbot/main.go | examples/memory_chatbot/main.go | package main
import (
"context"
"fmt"
"log"
"github.com/smallnest/langgraphgo/memory"
"github.com/tmc/langchaingo/llms"
langchainmemory "github.com/tmc/langchaingo/memory"
)
func main() {
ctx := context.Background()
fmt.Println("=== Memory-Enabled Chatbot Simulation ===")
// Example 1: Chatbot with ConversationBuffer
fmt.Println("--- Example 1: Full Memory (ConversationBuffer) ---")
runChatbotSimulation(ctx, "buffer", 2)
// Example 2: Chatbot with ConversationWindowBuffer
fmt.Println("\n--- Example 2: Window Memory (Last 2 Turns) ---")
runChatbotSimulation(ctx, "window", 2)
// Example 3: Demonstrate memory persistence
fmt.Println("\n--- Example 3: Memory Persistence ---")
demonstrateMemoryPersistence(ctx)
}
// runChatbotSimulation simulates a chatbot conversation with memory
func runChatbotSimulation(ctx context.Context, memoryType string, windowSize int) {
// Create memory based on type
var mem *memory.LangChainMemory
switch memoryType {
case "buffer":
mem = memory.NewConversationBufferMemory(
langchainmemory.WithReturnMessages(true),
)
case "window":
mem = memory.NewConversationWindowBufferMemory(windowSize,
langchainmemory.WithReturnMessages(true),
)
default:
mem = memory.NewConversationBufferMemory(
langchainmemory.WithReturnMessages(true),
)
}
// Simulate conversation
conversations := []struct {
input string
output string
}{
{
"Hello! My name is Alice and I love programming in Go.",
"Hi Alice! It's great to meet you. Go is an excellent programming language! What aspects of Go do you enjoy most?",
},
{
"What's my name?",
"Your name is Alice, as you mentioned in your first message.",
},
{
"What programming language do I like?",
"You mentioned that you love programming in Go!",
},
{
"Can you remind me what we talked about?",
"We talked about your name (Alice) and your love for Go programming. You asked me to confirm your name and the programming language you like.",
},
}
for i, conv := range conversations {
fmt.Printf("\n[Turn %d]\n", i+1)
// Load memory before processing
memVars, err := mem.LoadMemoryVariables(ctx, map[string]any{})
if err != nil {
log.Printf("Error loading memory: %v\n", err)
continue
}
// Get historical messages
var historyMessages []llms.ChatMessage
if history, ok := memVars["history"]; ok {
if msgs, ok := history.([]llms.ChatMessage); ok {
historyMessages = msgs
}
}
fmt.Printf("Memory: %d previous messages\n", len(historyMessages))
fmt.Printf("User: %s\n", conv.input)
fmt.Printf("Bot: %s\n", conv.output)
// Save to memory
err = mem.SaveContext(ctx, map[string]any{
"input": conv.input,
}, map[string]any{
"output": conv.output,
})
if err != nil {
log.Printf("Error saving context: %v\n", err)
}
}
// Show final memory state
fmt.Println("\n--- Final Memory State ---")
messages, err := mem.GetMessages(ctx)
if err != nil {
log.Printf("Error getting messages: %v\n", err)
return
}
fmt.Printf("Total messages in memory: %d\n", len(messages))
for i, msg := range messages {
content := msg.GetContent()
if len(content) > 60 {
content = content[:60] + "..."
}
fmt.Printf(" [%d] %s: %s\n", i+1, msg.GetType(), content)
}
}
// demonstrateMemoryPersistence shows how memory persists across interactions
func demonstrateMemoryPersistence(ctx context.Context) {
// Create a custom chat history
chatHistory := memory.NewChatMessageHistory()
// Add initial messages
chatHistory.AddUserMessage(ctx, "I'm learning about LangGraph")
chatHistory.AddAIMessage(ctx, "That's great! LangGraph is a powerful framework for building stateful, multi-actor applications.")
// Create memory with the custom chat history
mem := memory.NewConversationBufferMemory(
langchainmemory.WithChatHistory(chatHistory.GetHistory()),
langchainmemory.WithReturnMessages(true),
)
fmt.Println("Initial memory loaded from chat history:")
messages, _ := mem.GetMessages(ctx)
for i, msg := range messages {
fmt.Printf(" [%d] %s: %s\n", i+1, msg.GetType(), msg.GetContent())
}
// Add more conversation
fmt.Println("\nContinuing conversation:")
newConversations := []struct {
input string
output string
}{
{
"What can I build with it?",
"You can build chatbots, agents, multi-step workflows, and complex AI applications with memory and state management.",
},
{
"What was I learning about?",
"You mentioned you're learning about LangGraph!",
},
}
for i, conv := range newConversations {
fmt.Printf("\n[Turn %d]\n", i+1)
fmt.Printf("User: %s\n", conv.input)
fmt.Printf("Bot: %s\n", conv.output)
mem.SaveContext(ctx, map[string]any{
"input": conv.input,
}, map[string]any{
"output": conv.output,
})
}
// Show complete history
fmt.Println("\n--- Complete Conversation History ---")
messages, _ = mem.GetMessages(ctx)
fmt.Printf("Total messages: %d\n", len(messages))
for i, msg := range messages {
fmt.Printf(" [%d] %s: %s\n", i+1, msg.GetType(), msg.GetContent())
}
fmt.Println("\nKey Takeaway:")
fmt.Println(" - Memory can be initialized with existing chat history")
fmt.Println(" - New conversations build on top of existing history")
fmt.Println(" - Perfect for resuming conversations or multi-session chats")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/generic_state_graph_listenable/main.go | examples/generic_state_graph_listenable/main.go | package main
import (
"context"
"fmt"
"github.com/smallnest/langgraphgo/graph"
)
// TypedState represents a strongly typed state
type TypedState struct {
Count int
Log []string
}
func main() {
// Create a typed graph
g := graph.NewListenableStateGraph[TypedState]()
// Add a node
node := g.AddNode("increment", "Increment counter", func(ctx context.Context, state TypedState) (TypedState, error) {
state.Count++
state.Log = append(state.Log, "Incremented")
return state, nil
})
// Add a typed listener using NodeListenerFunc
listener := graph.NodeListenerFunc[TypedState](
func(ctx context.Context, event graph.NodeEvent, nodeName string, state TypedState, err error) {
fmt.Printf("[Listener] Event: %s, Node: %s, Count: %d\n", event, nodeName, state.Count)
},
)
node.AddListener(listener)
g.SetEntryPoint("increment")
g.AddEdge("increment", graph.END)
runnable, err := g.CompileListenable()
if err != nil {
panic(err)
}
initialState := TypedState{Count: 0, Log: []string{}}
result, err := runnable.Invoke(context.Background(), initialState)
if err != nil {
panic(err)
}
fmt.Printf("Final State: %+v\n", result)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/supervisor/main.go | examples/supervisor/main.go | package main
import (
"context"
"fmt"
"log"
"os"
"strconv"
"strings"
"time"
"github.com/smallnest/langgraphgo/graph"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
"github.com/tmc/langchaingo/tools"
)
// CalculatorTool (same as in react_agent example)
type CalculatorTool struct{}
func (t CalculatorTool) Name() string {
return "calculator"
}
func (t CalculatorTool) Description() string {
return "Useful for performing basic arithmetic operations. Input should be a string like '2 + 2' or '5 * 10'."
}
func (t CalculatorTool) Call(ctx context.Context, input string) (string, error) {
parts := strings.Fields(input)
if len(parts) != 3 {
return "", fmt.Errorf("invalid input format")
}
a, _ := strconv.ParseFloat(parts[0], 64)
b, _ := strconv.ParseFloat(parts[2], 64)
op := parts[1]
var result float64
switch op {
case "+":
result = a + b
case "-":
result = a - b
case "*":
result = a * b
case "/":
result = a / b
}
return fmt.Sprintf("%f", result), nil
}
func main() {
if os.Getenv("OPENAI_API_KEY") == "" {
log.Fatal("OPENAI_API_KEY not set")
}
// Initialize LLM
opts := []openai.Option{}
if base := os.Getenv("OPENAI_API_BASE"); base != "" {
opts = append(opts, openai.WithBaseURL(base))
}
if modelName := os.Getenv("OPENAI_MODEL"); modelName != "" {
opts = append(opts, openai.WithModel(modelName))
}
model, err := openai.New(opts...)
if err != nil {
log.Fatal(err)
}
// 1. Create Math Agent
mathAgent, err := prebuilt.CreateAgentMap(model, []tools.Tool{CalculatorTool{}}, 20)
if err != nil {
log.Fatal(err)
}
// 2. Create General Agent
generalAgent, err := prebuilt.CreateAgentMap(model, []tools.Tool{}, 20)
if err != nil {
log.Fatal(err)
}
// 3. Create Supervisor
g := graph.NewStateGraph[map[string]any]()
agentNode := func(agent *graph.StateRunnable[map[string]any]) func(context.Context, map[string]any) (map[string]any, error) {
return func(ctx context.Context, state map[string]any) (map[string]any, error) {
return agent.Invoke(ctx, state)
}
}
g.AddNode("MathExpert", "Math Agent", agentNode(mathAgent))
g.AddNode("GeneralAssistant", "General Agent", agentNode(generalAgent))
supervisorNode := func(ctx context.Context, state map[string]any) (map[string]any, error) {
messages := state["messages"].([]llms.MessageContent)
systemPrompt := `You are a supervisor tasked with managing a conversation between the following workers:
- MathExpert
- GeneralAssistant
Given the conversation, decide who should act next.
If the task is finished, return FINISH.
Return only the name of the next actor or FINISH.`
// Combine system prompt with history
msgs := []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeSystem, systemPrompt),
}
msgs = append(msgs, messages...)
resp, err := model.GenerateContent(ctx, msgs)
if err != nil {
return nil, err
}
choice := strings.TrimSpace(resp.Choices[0].Content)
fmt.Printf("DEBUG: Supervisor choice raw: %q\n", choice)
// Robust parsing
choiceLower := strings.ToLower(choice)
if strings.Contains(choiceLower, "mathexpert") {
choice = "MathExpert"
} else if strings.Contains(choiceLower, "generalassistant") {
choice = "GeneralAssistant"
} else if strings.Contains(choiceLower, "finish") {
choice = "FINISH"
} else {
fmt.Printf("WARNING: Supervisor returned unknown choice: %s. Defaulting to FINISH.\n", choice)
choice = "FINISH"
}
state["next"] = choice
return state, nil
}
g.AddNode("Supervisor", "Supervisor", supervisorNode)
g.SetEntryPoint("Supervisor")
g.AddConditionalEdge("Supervisor", func(ctx context.Context, state map[string]any) string {
next, _ := state["next"].(string)
if next == "FINISH" {
return graph.END
}
return next
})
g.AddEdge("MathExpert", "Supervisor")
g.AddEdge("GeneralAssistant", "Supervisor")
supervisor, err := g.Compile()
if err != nil {
log.Fatal(err)
}
// Execute
query := "Calculate 10 * 5 and then tell me a joke about the result."
fmt.Printf("User: %s\n", query)
initialState := map[string]any{
"messages": []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeHuman, query),
},
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
res, err := supervisor.Invoke(ctx, initialState)
if err != nil {
log.Fatal(err)
}
// Print Result
messages := res["messages"].([]llms.MessageContent)
fmt.Println("\n=== Conversation History ===")
for _, msg := range messages {
role := msg.Role
var content string
if len(msg.Parts) > 0 {
if textPart, ok := msg.Parts[0].(llms.TextContent); ok {
content = textPart.Text
} else if _, ok := msg.Parts[0].(llms.ToolCall); ok {
content = "[Tool Call]"
} else if _, ok := msg.Parts[0].(llms.ToolCallResponse); ok {
content = "[Tool Response]"
}
}
fmt.Printf("%s: %s\n", role, content)
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/subgraph/main.go | examples/subgraph/main.go | package main
import (
"context"
"fmt"
"github.com/smallnest/langgraphgo/graph"
)
func main() {
fmt.Println("=== Subgraph Example ===")
// 1. Define Main Graph
main := graph.NewStateGraph[map[string]any]()
// 2. Define Subgraph 1 (Validation)
validationSubgraph := graph.NewStateGraph[map[string]any]()
validationSubgraph.AddNode("check_format", "check_format", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Validation] Checking format...")
return map[string]any{"format_ok": true}, nil
})
validationSubgraph.AddNode("sanitize", "sanitize", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Validation] Sanitizing input...")
return map[string]any{"sanitized": true}, nil
})
validationSubgraph.SetEntryPoint("check_format")
validationSubgraph.AddEdge("check_format", "sanitize")
validationSubgraph.AddEdge("sanitize", graph.END)
// 3. Define Subgraph 2 (Processing)
processingSubgraph := graph.NewStateGraph[map[string]any]()
processingSubgraph.AddNode("transform", "transform", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Processing] Transforming data...")
return map[string]any{"transformed": true}, nil
})
processingSubgraph.AddNode("enrich", "enrich", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Processing] Enriching data...")
return map[string]any{"enriched": true}, nil
})
processingSubgraph.SetEntryPoint("transform")
processingSubgraph.AddEdge("transform", "enrich")
processingSubgraph.AddEdge("enrich", graph.END)
// 4. Add Nodes to Main Graph
main.AddNode("receive", "receive", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Main] Received request")
return state, nil
})
// Add subgraphs
// Use AddSubgraph with generic types
graph.AddSubgraph(main, "validation", validationSubgraph,
func(s map[string]any) map[string]any { return s },
func(s map[string]any) map[string]any { return s })
graph.AddSubgraph(main, "processing", processingSubgraph,
func(s map[string]any) map[string]any { return s },
func(s map[string]any) map[string]any { return s })
main.AddNode("finalize", "finalize", func(ctx context.Context, state map[string]any) (map[string]any, error) {
fmt.Println("[Main] Finalizing response")
return map[string]any{"status": "completed"}, nil
})
// 5. Connect Main Graph
main.SetEntryPoint("receive")
main.AddEdge("receive", "validation")
main.AddEdge("validation", "processing")
main.AddEdge("processing", "finalize")
main.AddEdge("finalize", graph.END)
// 6. Compile and Run
runnable, err := main.Compile()
if err != nil {
panic(err)
}
fmt.Println("Running combined workflow...")
res, err := runnable.Invoke(context.Background(), map[string]any{"input": "data"})
if err != nil {
panic(err)
}
fmt.Printf("Final State: %v\n", res)
// Example of using CreateSubgraph builder
fmt.Println("\n=== CreateSubgraph Builder Example ===")
g2 := graph.NewStateGraph[map[string]any]()
graph.CreateSubgraph(g2, "dynamic_sub", func(sg *graph.StateGraph[map[string]any]) error {
sg.AddNode("step1", "step1", func(ctx context.Context, state map[string]any) (map[string]any, error) {
return map[string]any{"dynamic_step1": true}, nil
})
sg.AddNode("step2", "step2", func(ctx context.Context, state map[string]any) (map[string]any, error) {
return map[string]any{"dynamic_step2": true}, nil
})
sg.SetEntryPoint("step1")
sg.AddEdge("step1", "step2")
sg.AddEdge("step2", graph.END)
return nil
},
func(s map[string]any) map[string]any { return s },
func(s map[string]any) map[string]any { return s })
g2.SetEntryPoint("dynamic_sub")
g2.AddEdge("dynamic_sub", graph.END)
r2, _ := g2.Compile()
res2, _ := r2.Invoke(context.Background(), map[string]any{})
fmt.Printf("Dynamic Subgraph Result: %v\n", res2)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/memory_agent/main.go | examples/memory_agent/main.go | package main
import (
"bufio"
"context"
"fmt"
"os"
"strings"
"time"
"github.com/smallnest/langgraphgo/memory"
)
// AgentState represents the state of our chat agent
type AgentState struct {
Messages []string
UserInput string
Response string
MemoryStats *memory.Stats
CurrentTopic string
}
// ChatAgent is a simple agent that uses memory strategies
type ChatAgent struct {
memory memory.Memory
strategy string
ctx context.Context
}
// NewChatAgent creates a new chat agent with specified memory strategy
func NewChatAgent(strategyName string) *ChatAgent {
ctx := context.Background()
var mem memory.Memory
switch strategyName {
case "sequential":
mem = memory.NewSequentialMemory()
case "sliding":
mem = memory.NewSlidingWindowMemory(5) // Keep last 5 messages
case "buffer":
mem = memory.NewBufferMemory(&memory.BufferConfig{
MaxMessages: 8,
MaxTokens: 500,
})
case "summarization":
mem = memory.NewSummarizationMemory(&memory.SummarizationConfig{
RecentWindowSize: 3,
SummarizeAfter: 6,
})
case "retrieval":
mem = memory.NewRetrievalMemory(&memory.RetrievalConfig{
TopK: 3,
})
case "hierarchical":
mem = memory.NewHierarchicalMemory(&memory.HierarchicalConfig{
RecentLimit: 3,
ImportantLimit: 5,
})
case "graph":
mem = memory.NewGraphBasedMemory(&memory.GraphConfig{
TopK: 4,
})
case "compression":
mem = memory.NewCompressionMemory(&memory.CompressionConfig{
CompressionTrigger: 5,
})
case "oslike":
mem = memory.NewOSLikeMemory(&memory.OSLikeConfig{
ActiveLimit: 3,
CacheLimit: 5,
AccessWindow: time.Minute * 5,
})
default:
mem = memory.NewBufferMemory(&memory.BufferConfig{
MaxMessages: 10,
})
}
return &ChatAgent{
memory: mem,
strategy: strategyName,
ctx: ctx,
}
}
// ProcessMessage handles incoming user messages
func (a *ChatAgent) ProcessMessage(userMsg string) (string, error) {
// Add user message to memory
msg := memory.NewMessage("user", userMsg)
// Mark important messages
if strings.Contains(strings.ToLower(userMsg), "important") ||
strings.Contains(strings.ToLower(userMsg), "remember") {
msg.Metadata["importance"] = 0.9
}
if err := a.memory.AddMessage(a.ctx, msg); err != nil {
return "", err
}
// Get relevant context from memory
context, err := a.memory.GetContext(a.ctx, userMsg)
if err != nil {
return "", err
}
// Generate response based on context
response := a.generateResponse(userMsg, context)
// Add response to memory
responseMsg := memory.NewMessage("assistant", response)
if err := a.memory.AddMessage(a.ctx, responseMsg); err != nil {
return "", err
}
return response, nil
}
// generateResponse simulates an LLM response based on context
func (a *ChatAgent) generateResponse(input string, context []*memory.Message) string {
inputLower := strings.ToLower(input)
// Greetings
if strings.Contains(inputLower, "hello") || strings.Contains(inputLower, "hi") {
return "Hello! I'm your assistant. How can I help you today?"
}
// Product price queries
if strings.Contains(inputLower, "price") {
// Check if we mentioned price before in context
for _, msg := range context {
if strings.Contains(strings.ToLower(msg.Content), "$99") {
return "As I mentioned before, the product is priced at $99."
}
}
return "Our premium product is priced at $99, which includes free shipping!"
}
// Name queries
if strings.Contains(inputLower, "my name") || strings.Contains(inputLower, "i am") {
// Extract name from input
words := strings.Fields(input)
for i, word := range words {
if (strings.ToLower(word) == "am" || strings.ToLower(word) == "name") && i+1 < len(words) {
name := words[i+1]
return fmt.Sprintf("Nice to meet you, %s! I'll remember your name.", name)
}
}
}
// Check if we know the user's name from context
userName := ""
for _, msg := range context {
if msg.Role == "user" && (strings.Contains(msg.Content, "I am") || strings.Contains(msg.Content, "My name")) {
words := strings.Fields(msg.Content)
for i, word := range words {
if (strings.ToLower(word) == "am" || strings.ToLower(word) == "name") && i+1 < len(words) {
userName = words[i+1]
break
}
}
}
}
if userName != "" && (strings.Contains(inputLower, "who am i") || strings.Contains(inputLower, "remember me")) {
return fmt.Sprintf("Of course I remember you, %s!", userName)
}
// Features query
if strings.Contains(inputLower, "feature") {
return "Our product has amazing features: waterproof design, 24-hour battery life, and AI-powered assistance!"
}
// Warranty query
if strings.Contains(inputLower, "warranty") {
return "Yes! We offer a 2-year warranty covering all manufacturing defects."
}
// Shipping query
if strings.Contains(inputLower, "shipping") || strings.Contains(inputLower, "delivery") {
return "We offer free standard shipping (3-5 business days) and express shipping ($15, 1-2 days)."
}
// Context-based responses
if len(context) > 2 {
return fmt.Sprintf("Based on our conversation (I remember %d messages), I'm here to help with any questions about our products!", len(context))
}
// Default response
return "I understand. Could you please provide more details about what you're looking for?"
}
// GetStats returns current memory statistics
func (a *ChatAgent) GetStats() (*memory.Stats, error) {
return a.memory.GetStats(a.ctx)
}
// Demo functions for different scenarios
func demoCustomerSupport() {
fmt.Println("\n=== Customer Support Scenario ===")
fmt.Println("Strategy: Sliding Window (keeps last 5 messages)")
fmt.Println("Use case: Recent conversation context is most important")
agent := NewChatAgent("sliding")
conversation := []string{
"Hello!",
"What's the price of your product?",
"Does it have good features?",
"Tell me about the warranty",
"What about shipping?",
"Can you remind me of the price again?", // Tests memory recall
}
for _, msg := range conversation {
fmt.Printf("User: %s\n", msg)
response, _ := agent.ProcessMessage(msg)
fmt.Printf("Agent: %s\n", response)
stats, _ := agent.GetStats()
fmt.Printf(" [Memory: %d messages, %d tokens]\n\n", stats.TotalMessages, stats.TotalTokens)
time.Sleep(100 * time.Millisecond)
}
}
func demoLongConsultation() {
fmt.Println("\n=== Long Consultation Scenario ===")
fmt.Println("Strategy: Summarization (summarizes old, keeps recent)")
fmt.Println("Use case: Long sessions where history matters")
agent := NewChatAgent("summarization")
// Simulate longer conversation
conversation := []string{
"Hi, I'm John",
"I'm interested in your product",
"IMPORTANT: I need it to be waterproof",
"What's the price?",
"Tell me about features",
"Any warranty?",
"What are shipping options?",
"Do you remember my name?", // Tests long-term memory
"And my waterproof requirement?",
}
for _, msg := range conversation {
fmt.Printf("User: %s\n", msg)
response, _ := agent.ProcessMessage(msg)
fmt.Printf("Agent: %s\n", response)
stats, _ := agent.GetStats()
fmt.Printf(" [Memory: %d total, %d active messages]\n\n",
stats.TotalMessages, stats.ActiveMessages)
time.Sleep(100 * time.Millisecond)
}
}
func demoKnowledgeBase() {
fmt.Println("\n=== Knowledge Base Scenario ===")
fmt.Println("Strategy: Retrieval (retrieves relevant messages)")
fmt.Println("Use case: Large history, query-driven retrieval")
agent := NewChatAgent("retrieval")
// Add various information
conversation := []string{
"What's the price?",
"Tell me about features",
"Shipping information?",
"Warranty details?",
"Available colors?",
"Tell me about the price again", // Should retrieve price-related messages
}
for _, msg := range conversation {
fmt.Printf("User: %s\n", msg)
response, _ := agent.ProcessMessage(msg)
fmt.Printf("Agent: %s\n", response)
stats, _ := agent.GetStats()
fmt.Printf(" [Memory: %d total messages stored]\n\n", stats.TotalMessages)
time.Sleep(100 * time.Millisecond)
}
}
func demoImportantInfo() {
fmt.Println("\n=== Important Information Tracking ===")
fmt.Println("Strategy: Hierarchical (keeps important + recent)")
fmt.Println("Use case: Some messages more important than others")
agent := NewChatAgent("hierarchical")
conversation := []string{
"Hello!",
"IMPORTANT: Remember I'm allergic to latex",
"What's the price?",
"Tell me about features",
"Any latex in the materials?", // Should remember the allergy
"What about warranty?",
"Shipping options?",
"Just to confirm - you remember my allergy?",
}
for _, msg := range conversation {
fmt.Printf("User: %s\n", msg)
response, _ := agent.ProcessMessage(msg)
fmt.Printf("Agent: %s\n", response)
stats, _ := agent.GetStats()
fmt.Printf(" [Memory: %d total, %d active]\n\n",
stats.TotalMessages, stats.ActiveMessages)
time.Sleep(100 * time.Millisecond)
}
}
func demoGraphRelationships() {
fmt.Println("\n=== Topic Relationship Tracking ===")
fmt.Println("Strategy: Graph-Based (tracks topic relationships)")
fmt.Println("Use case: Related topics and cross-references")
agent := NewChatAgent("graph")
conversation := []string{
"What's the price of the product?",
"Tell me about features",
"Does the price include warranty?", // Relates price + warranty
"What features justify the price?", // Relates features + price
"Shipping costs?",
}
for _, msg := range conversation {
fmt.Printf("User: %s\n", msg)
response, _ := agent.ProcessMessage(msg)
fmt.Printf("Agent: %s\n", response)
stats, _ := agent.GetStats()
// Show relationships for graph strategy
if graphMem, ok := agent.memory.(*memory.GraphBasedMemory); ok {
relations := graphMem.GetRelationships()
fmt.Printf(" [Topics tracked: %v]\n\n", getKeys(relations))
} else {
fmt.Printf(" [Memory: %d messages]\n\n", stats.TotalMessages)
}
time.Sleep(100 * time.Millisecond)
}
}
func getKeys(m map[string]int) []string {
keys := make([]string, 0, len(m))
for k := range m {
keys = append(keys, k)
}
return keys
}
func interactiveDemo() {
fmt.Println("\n=== Interactive Mode ===")
fmt.Println("Choose a memory strategy:")
fmt.Println("1. Sequential (keep all)")
fmt.Println("2. Sliding Window (last 5)")
fmt.Println("3. Buffer (max 8 messages)")
fmt.Println("4. Summarization")
fmt.Println("5. Retrieval")
fmt.Println("6. Hierarchical")
fmt.Println("7. Graph-Based")
fmt.Println("8. Compression")
fmt.Println("9. OS-Like")
reader := bufio.NewReader(os.Stdin)
fmt.Print("\nEnter choice (1-9): ")
choiceStr, _ := reader.ReadString('\n')
choiceStr = strings.TrimSpace(choiceStr)
strategies := map[string]string{
"1": "sequential",
"2": "sliding",
"3": "buffer",
"4": "summarization",
"5": "retrieval",
"6": "hierarchical",
"7": "graph",
"8": "compression",
"9": "oslike",
}
strategyName, ok := strategies[choiceStr]
if !ok {
strategyName = "buffer"
}
agent := NewChatAgent(strategyName)
fmt.Printf("\nUsing %s strategy. Type 'quit' to exit.\n\n", strategyName)
for {
fmt.Print("You: ")
input, _ := reader.ReadString('\n')
input = strings.TrimSpace(input)
if strings.ToLower(input) == "quit" {
break
}
if input == "" {
continue
}
response, err := agent.ProcessMessage(input)
if err != nil {
fmt.Printf("Error: %v\n", err)
continue
}
fmt.Printf("Agent: %s\n", response)
stats, _ := agent.GetStats()
fmt.Printf(" [Memory: %d total, %d active messages, %.0f tokens]\n\n",
stats.TotalMessages, stats.ActiveMessages, float64(stats.TotalTokens))
}
}
func main() {
if len(os.Args) > 1 && os.Args[1] == "interactive" {
interactiveDemo()
return
}
fmt.Println("=== Memory-Powered Agent Demonstrations ===")
fmt.Println("Showing how different memory strategies affect agent behavior")
// Run different scenarios
demoCustomerSupport()
time.Sleep(500 * time.Millisecond)
demoLongConsultation()
time.Sleep(500 * time.Millisecond)
demoKnowledgeBase()
time.Sleep(500 * time.Millisecond)
demoImportantInfo()
time.Sleep(500 * time.Millisecond)
demoGraphRelationships()
fmt.Println("\n=== Summary ===")
fmt.Println("Different memory strategies provide different benefits:")
fmt.Println("- Sliding Window: Great for customer support (recent context)")
fmt.Println("- Summarization: Best for long consultations")
fmt.Println("- Retrieval: Perfect for knowledge bases")
fmt.Println("- Hierarchical: Excellent when importance varies")
fmt.Println("- Graph: Ideal for tracking topic relationships")
fmt.Println("\nRun with 'interactive' argument for interactive mode:")
fmt.Println(" go run main.go interactive")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/react_agent/main.go | examples/react_agent/main.go | package main
import (
"context"
"fmt"
"log"
"strconv"
"strings"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
"github.com/tmc/langchaingo/tools"
)
// CalculatorTool is a simple tool for demonstration
type CalculatorTool struct{}
func (t CalculatorTool) Name() string {
return "calculator"
}
func (t CalculatorTool) Description() string {
return "Useful for performing basic arithmetic operations. Input should be a string like '2 + 2' or '5 * 10'."
}
func (t CalculatorTool) Call(ctx context.Context, input string) (string, error) {
// Very simple parser for demo purposes
parts := strings.Fields(input)
if len(parts) != 3 {
return "", fmt.Errorf("invalid input format, expected 'a op b'")
}
a, err := strconv.ParseFloat(parts[0], 64)
if err != nil {
return "", err
}
b, err := strconv.ParseFloat(parts[2], 64)
if err != nil {
return "", err
}
op := parts[1]
var result float64
switch op {
case "+":
result = a + b
case "-":
result = a - b
case "*":
result = a * b
case "/":
if b == 0 {
return "", fmt.Errorf("division by zero")
}
result = a / b
default:
return "", fmt.Errorf("unknown operator: %s", op)
}
return fmt.Sprintf("%f", result), nil
}
func main() {
llm, err := openai.New()
if err != nil {
log.Fatal(err)
}
// Define Tools
inputTools := []tools.Tool{
CalculatorTool{},
}
// Create ReAct Agent using map state convenience function
agent, err := prebuilt.CreateAgentMap(llm, inputTools, 20)
if err != nil {
log.Fatal(err)
}
// Execute
query := "What is 25 * 4?"
fmt.Printf("User: %s\n", query)
initialState := map[string]any{
"messages": []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeHuman, query),
},
}
res, err := agent.Invoke(context.Background(), initialState)
if err != nil {
log.Fatal(err)
}
// Print Result
messages := res["messages"].([]llms.MessageContent)
lastMsg := messages[len(messages)-1]
if len(lastMsg.Parts) > 0 {
if textPart, ok := lastMsg.Parts[0].(llms.TextContent); ok {
fmt.Printf("Agent: %s\n", textPart.Text)
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/command_api/main.go | examples/command_api/main.go | package main
import (
"context"
"fmt"
"log"
"github.com/smallnest/langgraphgo/graph"
)
func main() {
// Create a new state graph
g := graph.NewStateGraph[any]()
g.AddNode("router", "router", func(ctx context.Context, state any) (any, error) {
m := state.(map[string]any)
val := m["value"].(int)
if val > 10 {
return &graph.Command{
Goto: "end_high",
Update: map[string]any{"path": "high"},
}, nil
}
return &graph.Command{
Goto: "process",
Update: map[string]any{"path": "normal"},
}, nil
})
g.AddNode("process", "process", func(ctx context.Context, state any) (any, error) {
m := state.(map[string]any)
val := m["value"].(int)
return map[string]any{"value": val * 2}, nil
})
g.AddNode("end_high", "end_high", func(ctx context.Context, state any) (any, error) {
m := state.(map[string]any)
val := m["value"].(int)
return map[string]any{"value": val + 100}, nil
})
g.SetEntryPoint("router")
g.AddEdge("process", graph.END)
g.AddEdge("end_high", graph.END)
runnable, err := g.Compile()
if err != nil {
log.Fatal(err)
}
// Test 1: Normal path
fmt.Println("--- Test 1: Normal Path ---")
res1, _ := runnable.Invoke(context.Background(), map[string]any{"value": 5})
fmt.Printf("Result (value=5): %v\n", res1)
// Test 2: High path
fmt.Println("\n--- Test 2: High Path ---")
res2, _ := runnable.Invoke(context.Background(), map[string]any{"value": 15})
fmt.Printf("Result (value=15): %v\n", res2)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/generic_state_graph/main.go | examples/generic_state_graph/main.go | package main
import (
"context"
"fmt"
"log"
"github.com/smallnest/langgraphgo/graph"
)
// UserRequest represents the input to our workflow
type UserRequest struct {
Name string
Age int
Country string
}
// WorkflowState represents the state of our workflow with full type safety
type WorkflowState struct {
Request UserRequest
IsAdult bool
IsEligible bool
Notifications []string
Result string
}
func main() {
fmt.Println("=== Generic StateGraph Example ===")
// Example 1: Simple type-safe graph
example1_SimpleGraph()
fmt.Println("\n" + repeat("=", 50) + "\n")
// Example 2: Conditional routing with type safety
example2_ConditionalRouting()
fmt.Println("\n" + repeat("=", 50) + "\n")
// Example 3: Using Schema for complex state merging
example3_WithSchema()
}
// Example 1: Simple type-safe graph
func example1_SimpleGraph() {
fmt.Println("Example 1: Simple Type-Safe Graph")
fmt.Println("-----------------------------------")
// Create a generic graph with WorkflowState type
g := graph.NewStateGraph[WorkflowState]()
// Add nodes with full type safety - no type assertions needed!
g.AddNode("check_age", "Check if user is adult", func(ctx context.Context, state WorkflowState) (WorkflowState, error) {
fmt.Printf("Checking age for %s (%d years old)\n", state.Request.Name, state.Request.Age)
state.IsAdult = state.Request.Age >= 18
state.Notifications = append(state.Notifications, fmt.Sprintf("Age check: %s is adult=%v", state.Request.Name, state.IsAdult))
return state, nil
})
g.AddNode("check_eligibility", "Check eligibility", func(ctx context.Context, state WorkflowState) (WorkflowState, error) {
fmt.Printf("Checking eligibility for %s\n", state.Request.Name)
// Type-safe field access - no casting needed!
state.IsEligible = state.IsAdult && state.Request.Country == "USA"
state.Notifications = append(state.Notifications, fmt.Sprintf("Eligibility: %v", state.IsEligible))
return state, nil
})
g.AddNode("finalize", "Generate final result", func(ctx context.Context, state WorkflowState) (WorkflowState, error) {
if state.IsEligible {
state.Result = fmt.Sprintf("✅ %s is eligible!", state.Request.Name)
} else {
state.Result = fmt.Sprintf("❌ %s is not eligible", state.Request.Name)
}
fmt.Printf("Final result: %s\n", state.Result)
return state, nil
})
// Define workflow edges
g.SetEntryPoint("check_age")
g.AddEdge("check_age", "check_eligibility")
g.AddEdge("check_eligibility", "finalize")
g.AddEdge("finalize", graph.END)
// Compile the graph
app, err := g.Compile()
if err != nil {
log.Fatal(err)
}
// Execute with type-safe input
initialState := WorkflowState{
Request: UserRequest{
Name: "Alice",
Age: 25,
Country: "USA",
},
Notifications: []string{},
}
// Invoke returns typed result - no type assertion needed!
finalState, err := app.Invoke(context.Background(), initialState)
if err != nil {
log.Fatal(err)
}
// Type-safe access to result
fmt.Printf("\nFinal State:\n")
fmt.Printf(" Result: %s\n", finalState.Result)
fmt.Printf(" Notifications: %d messages\n", len(finalState.Notifications))
}
// Example 2: Conditional routing with type safety
func example2_ConditionalRouting() {
fmt.Println("Example 2: Conditional Routing")
fmt.Println("-------------------------------")
g := graph.NewStateGraph[WorkflowState]()
g.AddNode("check_age", "Check age", func(ctx context.Context, state WorkflowState) (WorkflowState, error) {
fmt.Printf("Checking age for %s (%d years old)\n", state.Request.Name, state.Request.Age)
state.IsAdult = state.Request.Age >= 18
return state, nil
})
g.AddNode("adult_path", "Process adult", func(ctx context.Context, state WorkflowState) (WorkflowState, error) {
fmt.Println(" → Taking adult path")
state.Result = fmt.Sprintf("%s (adult) - Full access granted", state.Request.Name)
return state, nil
})
g.AddNode("minor_path", "Process minor", func(ctx context.Context, state WorkflowState) (WorkflowState, error) {
fmt.Println(" → Taking minor path")
state.Result = fmt.Sprintf("%s (minor) - Limited access", state.Request.Name)
return state, nil
})
// Type-safe conditional edge - no type assertions!
g.SetEntryPoint("check_age")
g.AddConditionalEdge("check_age", func(ctx context.Context, state WorkflowState) string {
// Full type safety here
if state.IsAdult {
return "adult_path"
}
return "minor_path"
})
g.AddEdge("adult_path", graph.END)
g.AddEdge("minor_path", graph.END)
app, _ := g.Compile()
// Test with adult
result1, _ := app.Invoke(context.Background(), WorkflowState{
Request: UserRequest{Name: "Bob", Age: 30},
})
fmt.Printf("Result: %s\n\n", result1.Result)
// Test with minor
result2, _ := app.Invoke(context.Background(), WorkflowState{
Request: UserRequest{Name: "Charlie", Age: 15},
})
fmt.Printf("Result: %s\n", result2.Result)
}
// Example 3: Using Schema for complex state merging
func example3_WithSchema() {
fmt.Println("Example 3: Using Schema for State Merging")
fmt.Println("-----------------------------------------")
// Define a state type
type ProcessState struct {
Items []string
Count int
MaxCount int
Processing bool
}
g := graph.NewStateGraph[ProcessState]()
// Create a schema with custom merge logic
schema := graph.NewStructSchema(
ProcessState{MaxCount: 5, Processing: true}, // Initial values
func(current, new ProcessState) (ProcessState, error) {
// Custom merge: append items, sum count, preserve MaxCount and Processing from current
current.Items = append(current.Items, new.Items...)
current.Count += new.Count
// Keep current.MaxCount and current.Processing
return current, nil
},
)
g.SetSchema(schema)
// Add processing node
g.AddNode("process", "Process items", func(ctx context.Context, state ProcessState) (ProcessState, error) {
item := fmt.Sprintf("item_%d", state.Count+1)
fmt.Printf("Processing: %s (count: %d/%d)\n", item, state.Count+1, state.MaxCount)
// Return partial update - schema will merge it!
return ProcessState{
Items: []string{item},
Count: 1, // This will be summed with current count
}, nil
})
// Conditional loop
g.SetEntryPoint("process")
g.AddConditionalEdge("process", func(ctx context.Context, state ProcessState) string {
if state.Count >= state.MaxCount {
return graph.END
}
return "process"
})
app, _ := g.Compile()
// Start with empty state - schema will initialize it
result, _ := app.Invoke(context.Background(), ProcessState{})
fmt.Printf("\nFinal State:\n")
fmt.Printf(" Items processed: %v\n", result.Items)
fmt.Printf(" Total count: %d\n", result.Count)
fmt.Printf(" Max count: %d\n", result.MaxCount)
fmt.Printf(" Processing: %v\n", result.Processing)
}
// Helper for string repetition (Go doesn't have built-in)
type stringHelper string
func (s stringHelper) repeat(n int) string {
result := ""
for i := 0; i < n; i++ {
result += string(s)
}
return result
}
// Add helper method to string type
func repeat(s string, n int) string {
result := ""
for i := 0; i < n; i++ {
result += s
}
return result
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/rag_with_langchain/main.go | examples/rag_with_langchain/main.go | package main
import (
"context"
"fmt"
"log"
"github.com/smallnest/langgraphgo/graph"
"github.com/smallnest/langgraphgo/rag"
"github.com/smallnest/langgraphgo/rag/retriever"
"github.com/smallnest/langgraphgo/rag/store"
"github.com/tmc/langchaingo/llms/openai"
)
func main() {
ctx := context.Background()
llm, err := openai.New()
if err != nil {
log.Fatalf("Failed to create LLM: %v", err)
}
documents := []rag.Document{
{Content: "LangChain is a framework for developing applications powered by language models."},
}
embedder := store.NewMockEmbedder(128)
vectorStore := store.NewInMemoryVectorStore(embedder)
texts := make([]string, len(documents))
for i, doc := range documents {
texts[i] = doc.Content
}
embeddings, _ := embedder.EmbedDocuments(ctx, texts)
vectorStore.AddBatch(ctx, documents, embeddings)
retriever := retriever.NewVectorStoreRetriever(vectorStore, embedder, 2)
config := rag.DefaultPipelineConfig()
config.Retriever = retriever
config.LLM = llm
pipeline := rag.NewRAGPipeline(config)
err = pipeline.BuildBasicRAG()
if err != nil {
log.Fatalf("Failed to build RAG pipeline: %v", err)
}
runnable, err := pipeline.Compile()
if err != nil {
log.Fatalf("Failed to compile pipeline: %v", err)
}
exporter := graph.GetGraphForRunnable(runnable)
fmt.Println(exporter.DrawASCII())
query := "What is LangChain?"
fmt.Printf("\nQuery: %s\n", query)
result, err := runnable.Invoke(ctx, map[string]any{
"query": query,
})
if err != nil {
log.Fatalf("Failed to process query: %v", err)
}
if answer, ok := result["answer"].(string); ok {
fmt.Printf("Answer: %s\n", answer)
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/context_store/main.go | examples/context_store/main.go | package main
import (
"context"
"fmt"
"time"
"github.com/smallnest/langgraphgo/graph"
)
type ProcessState struct {
Step int
Data string
History []string
}
func main() {
// Create a checkpointable graph with typed state
g := graph.NewCheckpointableStateGraph[ProcessState]()
// Define state schema with merger logic
// Since ProcessState is a struct, we can use a schema to merge partial updates if needed.
// But here nodes return full state (modified), so Overwrite is fine or default struct merge.
// Default struct merge overwrites non-zero fields.
// Let's use NewStructSchema.
schema := graph.NewStructSchema(
ProcessState{},
func(current, new ProcessState) (ProcessState, error) {
// For this example, we simply replace the state with the new one returned by the node
return new, nil
},
)
g.SetSchema(schema)
// Configure checkpointing
config := graph.CheckpointConfig{
Store: graph.NewMemoryCheckpointStore(),
AutoSave: true,
SaveInterval: 2 * time.Second,
MaxCheckpoints: 5,
}
g.SetCheckpointConfig(config)
// Add processing nodes
g.AddNode("step1", "step1", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 1
s.Data = s.Data + " → Step1"
s.History = append(s.History, "Completed Step 1")
fmt.Println("Executing Step 1...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
g.AddNode("step2", "step2", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 2
s.Data = s.Data + " → Step2"
s.History = append(s.History, "Completed Step 2")
fmt.Println("Executing Step 2...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
g.AddNode("step3", "step3", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 3
s.Data = s.Data + " → Step3"
s.History = append(s.History, "Completed Step 3")
fmt.Println("Executing Step 3...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
// Build the pipeline
g.SetEntryPoint("step1")
g.AddEdge("step1", "step2")
g.AddEdge("step2", "step3")
g.AddEdge("step3", graph.END)
// Compile checkpointable runnable
runnable, err := g.CompileCheckpointable()
if err != nil {
panic(err)
}
ctx := context.Background()
initialState := ProcessState{
Step: 0,
Data: "Start",
History: []string{"Initialized"},
}
fmt.Println("=== Starting execution with checkpointing ===")
// Execute with automatic checkpointing
result, err := runnable.Invoke(ctx, initialState)
if err != nil {
panic(err)
}
finalState := result
fmt.Printf("\n=== Execution completed ===\n")
fmt.Printf("Final Step: %d\n", finalState.Step)
fmt.Printf("Final Data: %s\n", finalState.Data)
fmt.Printf("History: %v\n", finalState.History)
// List saved checkpoints
checkpoints, err := runnable.ListCheckpoints(ctx)
if err != nil {
panic(err)
}
fmt.Printf("\n=== Created %d checkpoints ===\n", len(checkpoints))
for i, cp := range checkpoints {
fmt.Printf("Checkpoint %d: ID=%s, Time=%v\n", i+1, cp.ID, cp.Timestamp)
}
// Demonstrate resuming from a checkpoint
if len(checkpoints) > 1 {
fmt.Printf("\n=== Resuming from checkpoint %s ===\n", checkpoints[1].ID)
// Checkpoint stores generic 'any', need to cast if loading manually,
// but ResumeFromCheckpoint is not implemented in generic CheckpointableRunnable yet?
// Wait, I didn't implement ResumeFromCheckpoint in generic CheckpointableRunnable[S]!
// I only implemented LoadCheckpoint.
// Let's implement ResumeFromCheckpoint or just use LoadCheckpoint + Invoke.
// Actually, ResumeFromCheckpoint was convenient wrapper.
// But in the example I can just use LoadCheckpoint and cast.
cp, err := runnable.LoadCheckpoint(ctx, checkpoints[1].ID)
if err != nil {
fmt.Printf("Error loading checkpoint: %v\n", err)
} else {
// Ensure state is cast correctly
// Checkpoint.State is any. JSON unmarshal might make it map[string]any if using file store.
// But here we use MemoryStore which stores struct as is (if pointer) or value.
// Let's assume it's ProcessState.
var resumed ProcessState
if s, ok := cp.State.(ProcessState); ok {
resumed = s
} else {
// Handle map[string]any case if needed (e.g. if loaded from JSON)
// For now assuming MemoryStore preserves type
fmt.Printf("Warning: Checkpoint state type mismatch: %T\n", cp.State)
}
fmt.Printf("Resumed at Step: %d\n", resumed.Step)
fmt.Printf("Resumed Data: %s\n", resumed.Data)
fmt.Printf("Resumed History: %v\n", resumed.History)
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/context_store/sqlite/main.go | examples/context_store/sqlite/main.go | package main
import (
"context"
"encoding/json"
"fmt"
"os"
"time"
"github.com/smallnest/langgraphgo/graph"
"github.com/smallnest/langgraphgo/store/sqlite"
)
type ProcessState struct {
Step int
Data string
History []string
}
func main() {
// Check for Sqlite DB path
dbPath := os.Getenv("SQLITE_DB_PATH")
if dbPath == "" {
dbPath = "./checkpoints.db"
}
fmt.Printf("Using SQLite database at: %s\n", dbPath)
// Create a checkpointable graph with typed state
g := graph.NewCheckpointableStateGraph[ProcessState]()
// Define state schema
schema := graph.NewStructSchema(
ProcessState{},
func(current, new ProcessState) (ProcessState, error) {
return new, nil
},
)
g.SetSchema(schema)
// Initialize Sqlite Checkpoint Store
store, err := sqlite.NewSqliteCheckpointStore(sqlite.SqliteOptions{
Path: dbPath,
TableName: "example_checkpoints",
})
if err != nil {
panic(fmt.Errorf("failed to create sqlite store: %w", err))
}
defer store.Close()
// Configure checkpointing
config := graph.CheckpointConfig{
Store: store,
AutoSave: true,
SaveInterval: 2 * time.Second,
MaxCheckpoints: 5,
}
g.SetCheckpointConfig(config)
// Add processing nodes
g.AddNode("step1", "step1", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 1
s.Data = s.Data + " → Step1"
s.History = append(s.History, "Completed Step 1")
fmt.Println("Executing Step 1...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
g.AddNode("step2", "step2", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 2
s.Data = s.Data + " → Step2"
s.History = append(s.History, "Completed Step 2")
fmt.Println("Executing Step 2...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
g.AddNode("step3", "step3", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 3
s.Data = s.Data + " → Step3"
s.History = append(s.History, "Completed Step 3")
fmt.Println("Executing Step 3...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
// Build the pipeline
g.SetEntryPoint("step1")
g.AddEdge("step1", "step2")
g.AddEdge("step2", "step3")
g.AddEdge("step3", graph.END)
// Compile checkpointable runnable
runnable, err := g.CompileCheckpointable()
if err != nil {
panic(err)
}
ctx := context.Background()
initialState := ProcessState{
Step: 0,
Data: "Start",
History: []string{"Initialized"},
}
fmt.Println("=== Starting execution with SQLite checkpointing ===")
// Execute with automatic checkpointing
result, err := runnable.Invoke(ctx, initialState)
if err != nil {
panic(err)
}
finalState := result
fmt.Printf("\n=== Execution completed ===\n")
fmt.Printf("Final Step: %d\n", finalState.Step)
fmt.Printf("Final Data: %s\n", finalState.Data)
fmt.Printf("History: %v\n", finalState.History)
// List saved checkpoints
checkpoints, err := runnable.ListCheckpoints(ctx)
if err != nil {
panic(err)
}
fmt.Printf("\n=== Created %d checkpoints in SQLite ===\n", len(checkpoints))
for i, cp := range checkpoints {
fmt.Printf("Checkpoint %d: ID=%s, Time=%v\n", i+1, cp.ID, cp.Timestamp)
}
// Demonstrate resuming from a checkpoint
if len(checkpoints) > 1 {
fmt.Printf("\n=== Resuming from checkpoint %s ===\n", checkpoints[1].ID)
cp, err := runnable.LoadCheckpoint(ctx, checkpoints[1].ID)
if err != nil {
fmt.Printf("Error resuming: %v\n", err)
} else {
var resumed ProcessState
if s, ok := cp.State.(ProcessState); ok {
resumed = s
} else {
importJSON, _ := json.Marshal(cp.State)
json.Unmarshal(importJSON, &resumed)
}
fmt.Printf("Resumed at Step: %d\n", resumed.Step)
fmt.Printf("Resumed Data: %s\n", resumed.Data)
fmt.Printf("Resumed History: %v\n", resumed.History)
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/context_store/postgres/main.go | examples/context_store/postgres/main.go | package main
import (
"context"
"encoding/json"
"fmt"
"os"
"time"
"github.com/smallnest/langgraphgo/graph"
"github.com/smallnest/langgraphgo/store/postgres"
)
type ProcessState struct {
Step int
Data string
History []string
}
func main() {
// Check for Postgres connection string
connString := os.Getenv("POSTGRES_CONN_STRING")
if connString == "" {
fmt.Println("POSTGRES_CONN_STRING environment variable not set. Skipping execution.")
fmt.Println("To run this example, set POSTGRES_CONN_STRING to a valid PostgreSQL connection string.")
fmt.Println("Example: export POSTGRES_CONN_STRING=postgres://user:password@localhost:5432/dbname")
return
}
// Create a checkpointable graph with typed state
g := graph.NewCheckpointableStateGraph[ProcessState]()
// Define state schema
schema := graph.NewStructSchema(
ProcessState{},
func(current, new ProcessState) (ProcessState, error) {
return new, nil
},
)
g.SetSchema(schema)
// Initialize Postgres Checkpoint Store
store, err := postgres.NewPostgresCheckpointStore(context.Background(), postgres.PostgresOptions{
ConnString: connString,
TableName: "example_checkpoints",
})
if err != nil {
panic(fmt.Errorf("failed to create postgres store: %w", err))
}
defer store.Close()
// Initialize Schema
if err := store.InitSchema(context.Background()); err != nil {
panic(fmt.Errorf("failed to init schema: %w", err))
}
// Configure checkpointing
config := graph.CheckpointConfig{
Store: store,
AutoSave: true,
SaveInterval: 2 * time.Second,
MaxCheckpoints: 5,
}
g.SetCheckpointConfig(config)
// Add processing nodes
g.AddNode("step1", "step1", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 1
s.Data = s.Data + " → Step1"
s.History = append(s.History, "Completed Step 1")
fmt.Println("Executing Step 1...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
g.AddNode("step2", "step2", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 2
s.Data = s.Data + " → Step2"
s.History = append(s.History, "Completed Step 2")
fmt.Println("Executing Step 2...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
g.AddNode("step3", "step3", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 3
s.Data = s.Data + " → Step3"
s.History = append(s.History, "Completed Step 3")
fmt.Println("Executing Step 3...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
// Build the pipeline
g.SetEntryPoint("step1")
g.AddEdge("step1", "step2")
g.AddEdge("step2", "step3")
g.AddEdge("step3", graph.END)
// Compile checkpointable runnable
runnable, err := g.CompileCheckpointable()
if err != nil {
panic(err)
}
ctx := context.Background()
initialState := ProcessState{
Step: 0,
Data: "Start",
History: []string{"Initialized"},
}
fmt.Println("=== Starting execution with Postgres checkpointing ===")
// Execute with automatic checkpointing
result, err := runnable.Invoke(ctx, initialState)
if err != nil {
panic(err)
}
finalState := result
fmt.Printf("\n=== Execution completed ===\n")
fmt.Printf("Final Step: %d\n", finalState.Step)
fmt.Printf("Final Data: %s\n", finalState.Data)
fmt.Printf("History: %v\n", finalState.History)
// List saved checkpoints
checkpoints, err := runnable.ListCheckpoints(ctx)
if err != nil {
panic(err)
}
fmt.Printf("\n=== Created %d checkpoints in Postgres ===\n", len(checkpoints))
for i, cp := range checkpoints {
fmt.Printf("Checkpoint %d: ID=%s, Time=%v\n", i+1, cp.ID, cp.Timestamp)
}
// Demonstrate resuming from a checkpoint
if len(checkpoints) > 1 {
fmt.Printf("\n=== Resuming from checkpoint %s ===\n", checkpoints[1].ID)
cp, err := runnable.LoadCheckpoint(ctx, checkpoints[1].ID)
if err != nil {
fmt.Printf("Error resuming: %v\n", err)
} else {
// Since data is loaded from JSON (via Postgres), it typically comes back as map[string]any
// if the store implementation unmarshals into interface{}.
// Checkpoint.State is 'any'.
// We need to convert it back to ProcessState.
var resumed ProcessState
// Try direct assertion first
if s, ok := cp.State.(ProcessState); ok {
resumed = s
} else {
// Fallback to JSON roundtrip
importJSON, _ := json.Marshal(cp.State)
json.Unmarshal(importJSON, &resumed)
}
fmt.Printf("Resumed at Step: %d\n", resumed.Step)
fmt.Printf("Resumed Data: %s\n", resumed.Data)
fmt.Printf("Resumed History: %v\n", resumed.History)
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/context_store/redis/main.go | examples/context_store/redis/main.go | package main
import (
"context"
"encoding/json"
"fmt"
"os"
"time"
"github.com/smallnest/langgraphgo/graph"
"github.com/smallnest/langgraphgo/store/redis"
)
type ProcessState struct {
Step int
Data string
History []string
}
func main() {
// Check for Redis address
redisAddr := os.Getenv("REDIS_ADDR")
if redisAddr == "" {
redisAddr = "localhost:6379"
}
fmt.Printf("Using Redis at: %s\n", redisAddr)
// Create a checkpointable graph with typed state
g := graph.NewCheckpointableStateGraph[ProcessState]()
// Define state schema
schema := graph.NewStructSchema(
ProcessState{},
func(current, new ProcessState) (ProcessState, error) {
return new, nil
},
)
g.SetSchema(schema)
// Initialize Redis Checkpoint Store
store := redis.NewRedisCheckpointStore(redis.RedisOptions{
Addr: redisAddr,
Prefix: "example_checkpoints:",
TTL: 1 * time.Hour,
})
// Configure checkpointing
config := graph.CheckpointConfig{
Store: store,
AutoSave: true,
SaveInterval: 2 * time.Second,
MaxCheckpoints: 5,
}
g.SetCheckpointConfig(config)
// Add processing nodes
g.AddNode("step1", "step1", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 1
s.Data = s.Data + " → Step1"
s.History = append(s.History, "Completed Step 1")
fmt.Println("Executing Step 1...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
g.AddNode("step2", "step2", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 2
s.Data = s.Data + " → Step2"
s.History = append(s.History, "Completed Step 2")
fmt.Println("Executing Step 2...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
g.AddNode("step3", "step3", func(ctx context.Context, s ProcessState) (ProcessState, error) {
s.Step = 3
s.Data = s.Data + " → Step3"
s.History = append(s.History, "Completed Step 3")
fmt.Println("Executing Step 3...")
time.Sleep(500 * time.Millisecond) // Simulate work
return s, nil
})
// Build the pipeline
g.SetEntryPoint("step1")
g.AddEdge("step1", "step2")
g.AddEdge("step2", "step3")
g.AddEdge("step3", graph.END)
// Compile checkpointable runnable
runnable, err := g.CompileCheckpointable()
if err != nil {
panic(err)
}
ctx := context.Background()
initialState := ProcessState{
Step: 0,
Data: "Start",
History: []string{"Initialized"},
}
fmt.Println("=== Starting execution with Redis checkpointing ===")
// Execute with automatic checkpointing
result, err := runnable.Invoke(ctx, initialState)
if err != nil {
// If redis is not available, it might fail.
// For example purposes, we just panic.
fmt.Printf("Execution failed (is Redis running?): %v\n", err)
return
}
finalState := result
fmt.Printf("\n=== Execution completed ===\n")
fmt.Printf("Final Step: %d\n", finalState.Step)
fmt.Printf("Final Data: %s\n", finalState.Data)
fmt.Printf("History: %v\n", finalState.History)
// List saved checkpoints
checkpoints, err := runnable.ListCheckpoints(ctx)
if err != nil {
panic(err)
}
fmt.Printf("\n=== Created %d checkpoints in Redis ===\n", len(checkpoints))
for i, cp := range checkpoints {
fmt.Printf("Checkpoint %d: ID=%s, Time=%v\n", i+1, cp.ID, cp.Timestamp)
}
// Demonstrate resuming from a checkpoint
if len(checkpoints) > 1 {
fmt.Printf("\n=== Resuming from checkpoint %s ===\n", checkpoints[1].ID)
cp, err := runnable.LoadCheckpoint(ctx, checkpoints[1].ID)
if err != nil {
fmt.Printf("Error resuming: %v\n", err)
} else {
var resumed ProcessState
if s, ok := cp.State.(ProcessState); ok {
resumed = s
} else {
importJSON, _ := json.Marshal(cp.State)
json.Unmarshal(importJSON, &resumed)
}
fmt.Printf("Resumed at Step: %d\n", resumed.Step)
fmt.Printf("Resumed Data: %s\n", resumed.Data)
fmt.Printf("Resumed History: %v\n", resumed.History)
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/rag_falkordb_graph/main.go | examples/rag_falkordb_graph/main.go | package main
import (
"context"
"fmt"
"log"
"strings"
"time"
"github.com/smallnest/langgraphgo/adapter"
"github.com/smallnest/langgraphgo/rag"
"github.com/smallnest/langgraphgo/rag/engine"
"github.com/smallnest/langgraphgo/rag/store"
"github.com/tmc/langchaingo/llms/openai"
)
func main() {
ctx := context.Background()
// Initialize LLM (OpenAI in this example)
ollm, err := openai.New()
if err != nil {
log.Fatalf("Failed to create LLM: %v", err)
}
// Create adapter for our LLM interface
llm := adapter.NewOpenAIAdapter(ollm)
// Initialize embedder for entity extraction
embedder := store.NewMockEmbedder(128)
// FalkorDB connection string
// Format: falkordb://host:port/graph_name
// For local FalkorDB: falkordb://localhost:6379/rag_graph
falkorDBConnStr := "falkordb://localhost:6379/rag_graph"
// Create FalkorDB knowledge graph
fmt.Println("Initializing FalkorDB knowledge graph...")
kg, err := store.NewFalkorDBGraph(falkorDBConnStr)
if err != nil {
log.Fatalf("Failed to create FalkorDB knowledge graph: %v", err)
}
// Close the connection when done (type assert to access Close method)
defer func() {
if falkorDB, ok := kg.(*store.FalkorDBGraph); ok {
falkorDB.Close()
}
}()
// Configure GraphRAG engine
graphRAGConfig := rag.GraphRAGConfig{
ExtractionPrompt: `
Extract entities from the following text. Focus on these entity types: %s.
Return a JSON response with this structure:
{
"entities": [
{
"name": "entity_name",
"type": "entity_type",
"description": "brief description",
"properties": {}
}
]
}
Text: %s`,
EntityTypes: []string{
"PERSON",
"ORGANIZATION",
"LOCATION",
"PRODUCT",
"TECHNOLOGY",
"CONCEPT",
},
MaxDepth: 3,
}
// Create GraphRAG engine
fmt.Println("Creating GraphRAG engine...")
graphEngine, err := engine.NewGraphRAGEngine(graphRAGConfig, llm, embedder, kg)
if err != nil {
log.Fatalf("Failed to create GraphRAG engine: %v", err)
}
// Sample documents about technology companies and their products
documents := []rag.Document{
{
ID: "doc1",
Content: "Apple Inc. is a technology company headquartered in Cupertino, California. " +
"The company was founded by Steve Jobs, Steve Wozniak, and Ronald Wayne in 1976. " +
"Apple is known for its consumer electronics products including the iPhone, iPad, and Mac computers. " +
"The iPhone is a smartphone that runs on iOS, Apple's mobile operating system.",
Metadata: map[string]any{
"source": "apple_overview.txt",
"topic": "Apple Inc.",
},
},
{
ID: "doc2",
Content: "Microsoft Corporation is an American technology company based in Redmond, Washington. " +
"Founded by Bill Gates and Paul Allen in 1975, Microsoft develops software, hardware, and cloud services. " +
"The company's flagship products include the Windows operating system and Microsoft Office suite. " +
"Microsoft Azure is their cloud computing platform that competes with Amazon Web Services.",
Metadata: map[string]any{
"source": "microsoft_overview.txt",
"topic": "Microsoft Corporation",
},
},
{
ID: "doc3",
Content: "Google LLC is an American technology company and subsidiary of Alphabet Inc. " +
"Founded by Larry Page and Sergey Brin in 1998, Google is headquartered in Mountain View, California. " +
"The company is known for its search engine, Android mobile operating system, and web services. " +
"Google Chrome is a popular web browser, and Google Cloud Platform (GCP) is their cloud computing service.",
Metadata: map[string]any{
"source": "google_overview.txt",
"topic": "Google LLC",
},
},
{
ID: "doc4",
Content: "Tesla, Inc. is an American electric vehicle and clean energy company based in Palo Alto, California. " +
"Founded by Elon Musk, Tesla designs and manufactures electric cars, battery energy storage, and solar products. " +
"The Tesla Model S is an all-electric sedan, and the Model Y is a compact electric SUV. " +
"Tesla also operates the Supercharger network for electric vehicle charging.",
Metadata: map[string]any{
"source": "tesla_overview.txt",
"topic": "Tesla, Inc.",
},
},
{
ID: "doc5",
Content: "Amazon.com, Inc. is an American multinational technology company based in Seattle, Washington. " +
"Founded by Jeff Bezos in 1994, Amazon started as an online bookstore but has expanded to e-commerce, " +
"digital streaming, and artificial intelligence. Amazon Web Services (AWS) is the market leader in cloud computing. " +
"The Amazon Kindle is a popular e-reader device.",
Metadata: map[string]any{
"source": "amazon_overview.txt",
"topic": "Amazon.com, Inc.",
},
},
}
// Add documents to the knowledge graph
fmt.Println("Adding documents to knowledge graph...")
fmt.Println("(This will extract entities and relationships from each document)")
startTime := time.Now()
for _, doc := range documents {
fmt.Printf("Processing document: %s\n", doc.Metadata["topic"])
err := graphEngine.AddDocuments(ctx, []rag.Document{doc})
if err != nil {
log.Printf("Failed to add document %s: %v", doc.ID, err)
continue
}
}
processingTime := time.Since(startTime)
fmt.Printf("Knowledge graph construction completed in %v\n\n", processingTime)
// Test queries to demonstrate graph-based retrieval
queries := []string{
"What products does Apple make?",
"Who founded Microsoft and what are their main products?",
"Tell me about electric vehicle companies and their founders",
"What cloud computing services are available?",
"Which technology companies are based in California?",
}
fmt.Println("=== GraphRAG Query Examples ===\n")
for i, query := range queries {
fmt.Printf("=== Query %d ===\n", i+1)
fmt.Printf("Question: %s\n\n", query)
// Perform GraphRAG query
result, err := graphEngine.Query(ctx, query)
if err != nil {
log.Printf("Failed to process query: %v", err)
continue
}
// Display graph context
fmt.Println("Knowledge Graph Context:")
fmt.Println(strings.Repeat("-", 50))
fmt.Println(result.Context)
fmt.Println(strings.Repeat("-", 50))
// Display retrieved documents/sources
fmt.Printf("\nRetrieved %d sources:\n", len(result.Sources))
for j, source := range result.Sources {
fmt.Printf(" [%d] Source ID: %s\n", j+1, source.ID)
if topic, ok := source.Metadata["topic"]; ok {
fmt.Printf(" Topic: %v\n", topic)
}
fmt.Printf(" Content: %s\n\n", truncate(source.Content, 200))
}
// Display metadata
fmt.Printf("Query Metadata:\n")
fmt.Printf(" - Engine Type: %v\n", result.Metadata["engine_type"])
fmt.Printf(" - Entities Found: %v\n", result.Metadata["entities_found"])
fmt.Printf(" - Relationships: %v\n", result.Metadata["relationships"])
fmt.Printf(" - Confidence: %.2f\n", result.Confidence)
fmt.Printf(" - Response Time: %v\n", result.ResponseTime)
fmt.Println("\n" + strings.Repeat("=", 80) + "\n")
// Small delay between queries
time.Sleep(500 * time.Millisecond)
}
// Demonstrate entity exploration
fmt.Println("\n=== Entity Exploration Examples ===\n")
// Explore entities related to Apple
fmt.Println("1. Exploring entities related to 'Apple Inc.':")
relatedEntities, err := kg.GetRelatedEntities(ctx, "Apple Inc.", 2)
if err != nil {
log.Printf("Failed to get related entities: %v", err)
} else {
for _, entity := range relatedEntities {
fmt.Printf(" - %s (%s)\n", entity.Name, entity.Type)
}
}
// Search for specific entity type
fmt.Println("\n2. Searching for 'PERSON' entities:")
graphQuery := &rag.GraphQuery{
EntityTypes: []string{"PERSON"},
Limit: 10,
}
queryResult, err := kg.Query(ctx, graphQuery)
if err != nil {
log.Printf("Failed to query graph: %v", err)
} else {
fmt.Printf(" Found %d PERSON entities:\n", len(queryResult.Entities))
for _, entity := range queryResult.Entities {
fmt.Printf(" - %s: %v\n", entity.Name, entity.Properties)
}
}
// Display relationships
fmt.Println("\n3. Relationships found in the graph:")
graphQuery = &rag.GraphQuery{
Limit: 20,
}
queryResult, err = kg.Query(ctx, graphQuery)
if err != nil {
log.Printf("Failed to query graph: %v", err)
} else {
fmt.Printf(" Found %d relationships:\n", len(queryResult.Relationships))
for _, rel := range queryResult.Relationships {
fmt.Printf(" - %s -> %s (%s)\n", rel.Source, rel.Target, rel.Type)
}
}
fmt.Println("\n=== Example Complete ===")
fmt.Println("This example demonstrated:")
fmt.Println("- Creating a knowledge graph with FalkorDB")
fmt.Println("- Extracting entities and relationships from documents")
fmt.Println("- Performing graph-based retrieval with GraphRAG")
fmt.Println("- Exploring entities and relationships in the knowledge graph")
}
func truncate(s string, maxLen int) string {
if len(s) <= maxLen {
return s
}
return s[:maxLen] + "..."
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/payment_interrupt/main.go | examples/payment_interrupt/main.go | package main
import (
"context"
"errors"
"fmt"
"log"
"strings"
"github.com/smallnest/langgraphgo/graph"
)
// OrderState represents the state of an order with payment processing
type OrderState struct {
OrderID string
Amount float64
PaymentStatus string
PaymentMethod string
TransactionID string
CustomerID string
Timestamp string
}
func main() {
fmt.Println("=== Payment Processing with Dynamic Interrupt Demo ===")
fmt.Println("This example demonstrates Issue #67 fix:")
fmt.Println("State modifications before Interrupt() are now correctly preserved.\n")
// Create a typed state graph
g := graph.NewStateGraph[OrderState]()
// Node 1: Initialize payment
g.AddNode("init_payment", "Initialize payment", func(ctx context.Context, state OrderState) (OrderState, error) {
fmt.Println("📝 [init_payment] Initializing payment...")
state.PaymentStatus = "initialized"
state.Timestamp = "2024-01-01T10:00:00Z"
fmt.Printf(" Status: %s\n", state.PaymentStatus)
return state, nil
})
// Node 2: Process payment - this is where we modify state and then interrupt
g.AddNode("process_payment", "Process payment and await confirmation", func(ctx context.Context, state OrderState) (OrderState, error) {
fmt.Println("\n💳 [process_payment] Processing payment...")
// CRITICAL: Modify state BEFORE interrupting
// This simulates a payment system that creates a pending transaction
state.PaymentStatus = "pending_payment"
state.TransactionID = "TXN-" + state.OrderID + "-001"
fmt.Printf(" Created transaction: %s\n", state.TransactionID)
fmt.Printf(" Status updated to: %s\n", state.PaymentStatus)
fmt.Printf(" Amount: $%.2f\n", state.Amount)
// Now interrupt to get user confirmation
// Before the fix (Issue #67), these state changes would be lost!
fmt.Println(" ⏸️ Interrupting to request user confirmation...")
confirmationMsg := fmt.Sprintf("Please confirm payment of $%.2f via %s",
state.Amount, state.PaymentMethod)
userResponse, err := graph.Interrupt(ctx, confirmationMsg)
if err != nil {
// Return the modified state along with the interrupt error
return state, err
}
// If resumed and user confirmed
if userResponse != nil {
confirmed, ok := userResponse.(bool)
if !ok || !confirmed {
state.PaymentStatus = "cancelled"
fmt.Println(" ❌ Payment cancelled by user")
return state, nil
}
// User confirmed - complete the payment
state.PaymentStatus = "paid"
fmt.Println(" ✅ Payment confirmed and completed")
}
return state, nil
})
// Node 3: Finalize order
g.AddNode("finalize_order", "Finalize order", func(ctx context.Context, state OrderState) (OrderState, error) {
fmt.Println("\n📦 [finalize_order] Finalizing order...")
if state.PaymentStatus == "paid" {
fmt.Printf(" Order %s is ready for shipment\n", state.OrderID)
} else {
fmt.Printf(" Order %s requires manual review (status: %s)\n",
state.OrderID, state.PaymentStatus)
}
return state, nil
})
// Build the graph
g.SetEntryPoint("init_payment")
g.AddEdge("init_payment", "process_payment")
g.AddEdge("process_payment", "finalize_order")
g.AddEdge("finalize_order", graph.END)
runnable, err := g.Compile()
if err != nil {
log.Fatal(err)
}
// Initial state
initialState := OrderState{
OrderID: "ORD-2024-001",
Amount: 99.99,
CustomerID: "CUST-123",
PaymentMethod: "Credit Card",
}
fmt.Printf("\n🛒 Starting order: %s for customer %s\n",
initialState.OrderID, initialState.CustomerID)
fmt.Println(strings.Repeat("=", 60))
// ===== STEP 1: Initial Run (will interrupt) =====
fmt.Println("\n--- Step 1: Initial Execution ---")
result, err := runnable.Invoke(context.Background(), initialState)
var graphInterrupt *graph.GraphInterrupt
if errors.As(err, &graphInterrupt) {
fmt.Println("\n⚠️ Graph Interrupted!")
fmt.Printf(" Node: %s\n", graphInterrupt.Node)
fmt.Printf(" Question: %s\n", graphInterrupt.InterruptValue)
// IMPORTANT: Check that state was preserved
interruptState, ok := graphInterrupt.State.(OrderState)
if !ok {
log.Fatalf("Expected OrderState, got %T", graphInterrupt.State)
}
fmt.Println("\n📊 State at Interruption:")
fmt.Printf(" Order ID: %s\n", interruptState.OrderID)
fmt.Printf(" Payment Status: %s\n", interruptState.PaymentStatus)
fmt.Printf(" Transaction ID: %s\n", interruptState.TransactionID)
fmt.Printf(" Amount: $%.2f\n", interruptState.Amount)
// Verify the fix worked
if interruptState.PaymentStatus != "pending_payment" {
fmt.Println("\n❌ BUG: State was not preserved! Expected 'pending_payment', got:", interruptState.PaymentStatus)
fmt.Println(" This was the issue reported in #67")
} else {
fmt.Println("\n✅ SUCCESS: State modifications before Interrupt() were preserved!")
fmt.Println(" This confirms Issue #67 is fixed.")
}
// Simulate user input
fmt.Println("\n--- Step 2: User Confirmation ---")
fmt.Println("💬 Simulating user confirming payment...")
userConfirmed := true
// ===== STEP 2: Resume Execution =====
fmt.Println("\n--- Step 3: Resuming Execution ---")
config := &graph.Config{
ResumeValue: userConfirmed,
}
// Resume with the interrupted state
result, err = runnable.InvokeWithConfig(context.Background(), interruptState, config)
if err != nil {
log.Fatalf("Resume execution failed: %v", err)
}
fmt.Println("\n📊 Final State:")
fmt.Printf(" Order ID: %s\n", result.OrderID)
fmt.Printf(" Payment Status: %s\n", result.PaymentStatus)
fmt.Printf(" Transaction ID: %s\n", result.TransactionID)
fmt.Printf(" Amount: $%.2f\n", result.Amount)
if result.PaymentStatus == "paid" {
fmt.Println("\n🎉 Order completed successfully!")
}
} else if err != nil {
log.Fatalf("Execution failed: %v", err)
} else {
fmt.Println("Execution finished without interrupt (unexpected)")
fmt.Printf("Final state: %+v\n", result)
}
fmt.Println("\n" + strings.Repeat("=", 60))
fmt.Println("Demo completed!")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/subgraphs/main.go | examples/subgraphs/main.go | package main
import (
"context"
"fmt"
"github.com/smallnest/langgraphgo/graph"
)
func main() {
// 1. Create a child graph
child := graph.NewStateGraph[map[string]any]()
child.AddNode("child_process", "child_process", func(ctx context.Context, state map[string]any) (map[string]any, error) {
state["child_visited"] = true
return state, nil
})
child.SetEntryPoint("child_process")
child.AddEdge("child_process", graph.END)
// 2. Create parent graph
parent := graph.NewStateGraph[map[string]any]()
parent.AddNode("start", "start", func(ctx context.Context, state map[string]any) (map[string]any, error) {
state["parent_start"] = true
return state, nil
})
// Add child graph as a node
// Note: Generic AddSubgraph requires converters.
// Since both are map[string]any, we use identity.
err := graph.AddSubgraph(parent, "child_graph", child,
func(s map[string]any) map[string]any { return s },
func(s map[string]any) map[string]any { return s })
if err != nil {
panic(err)
}
parent.AddNode("end", "end", func(ctx context.Context, state map[string]any) (map[string]any, error) {
state["parent_end"] = true
return state, nil
})
parent.SetEntryPoint("start")
parent.AddEdge("start", "child_graph")
parent.AddEdge("child_graph", "end")
parent.AddEdge("end", graph.END)
runnable, err := parent.Compile()
if err != nil {
panic(err)
}
res, err := runnable.Invoke(context.Background(), map[string]any{})
if err != nil {
panic(err)
}
fmt.Printf("Result: %v\n", res)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/goskills_example/main.go | examples/goskills_example/main.go | package main
import (
"context"
"fmt"
"log"
"os"
"strings"
"github.com/smallnest/goskills"
adapter "github.com/smallnest/langgraphgo/adapter/goskills"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
"github.com/tmc/langchaingo/tools"
)
func main() {
// 1. Initialize LLM
if os.Getenv("OPENAI_API_KEY") == "" {
log.Fatal("OPENAI_API_KEY is not set")
}
llm, err := openai.New()
if err != nil {
log.Fatal(err)
}
// 2. Load Skills
// Assuming there is a "skills" directory in the current directory or somewhere accessible.
// For this example, we might need to create a dummy skill or assume one exists.
// Let's assume the user has some skills in "./skills".
// If not, we can try to create a temporary skill for demonstration.
skillsDir := "goskills_example/skills"
if _, err := os.Stat(skillsDir); os.IsNotExist(err) {
// Create a dummy skill for demonstration
err = createDummySkill(skillsDir)
if err != nil {
log.Fatal(err)
}
defer os.RemoveAll(skillsDir)
}
packages, err := goskills.ParseSkillPackages(skillsDir)
if err != nil {
log.Fatal(err)
}
if len(packages) == 0 {
log.Fatal("No skills found")
}
// 3. Convert Skills to Tools
var allTools []tools.Tool
var allSystemMessages strings.Builder
allSystemMessages.WriteString("You are a helpful assistant that can use skills.\n\n")
for _, skill := range packages {
fmt.Printf("Loading skill: %s\n", skill.Meta.Name)
skillTools, err := adapter.SkillsToTools(skill)
if err != nil {
log.Printf("Failed to convert skill %s to tools: %v", skill.Meta.Name, err)
continue
}
allTools = append(allTools, skillTools...)
allSystemMessages.WriteString(fmt.Sprintf("Skill: %s\n%s\n\n", skill.Meta.Name, skill.Body))
for _, t := range skillTools {
fmt.Printf("Tool: %s, Description: %s\n", t.Name(), t.Description())
}
}
if len(allTools) == 0 {
log.Fatal("No tools found from skills")
}
// 3. Create Agent with all skills
agent, err := prebuilt.CreateAgentMap(llm, allTools, 0,
prebuilt.WithSystemMessage("You are a powerful AI assistant with many skills. Use them wisely."),
)
if err != nil {
log.Fatal(err)
}
// 5. Run Agent
ctx := context.Background()
input := "Please use the available skill to say hello to the world."
resp, err := agent.Invoke(ctx, map[string]any{
"messages": []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeHuman, input),
},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Agent: %v\n", resp)
}
func createDummySkill(dir string) error {
err := os.MkdirAll(dir+"/hello_world", 0755)
if err != nil {
return err
}
meta := `---
name: hello_world
description: A fundamental skill that demonstrates the basic execution of a Python script. It serves as a "Hello, World!" example for the skill system, verifying that the environment is correctly set up and that the agent can execute scripts.
version: 1.0.0
license: MIT
---
## Overview
The ` + "`hello_world`" + ` skill is the simplest possible skill in the ecosystem. Its primary purpose is to validate the operational status of the skill runner and the agent's ability to invoke tools.
## Functionality
When invoked, this skill executes a Python script that prints a greeting message to the standard output. This confirms:
1. **Script Execution**: The agent can successfully locate and run a Python script.
2. **Output Capture**: The system can capture the standard output from the script and return it to the agent.
3. **Tool Integration**: The skill is correctly registered and accessible as a tool.
## Usage
This skill is typically used in the following scenarios:
- **System Health Check**: To verify that the agent and skill runner are functioning correctly.
- **Onboarding**: As a first step for developers learning how to create and use skills.
- **Debugging**: To isolate issues with script execution or tool invocation.
### Example Command
To use this skill, the agent can execute the following command:
` + "```python" + `
scripts/hello.py
` + "```" + `
## Implementation Details
The skill consists of a single Python script ` + "`hello.py`" + ` which performs a simple print operation. No external dependencies or complex logic are involved, ensuring that any failure is likely due to the environment or configuration rather than the skill itself.
`
err = os.WriteFile(dir+"/hello_world/SKILL.md", []byte(meta), 0644)
if err != nil {
return err
}
script := `
print("Hello, World from Python!")
`
err = os.WriteFile(dir+"/hello_world/scripts/hello.py", []byte(script), 0644)
if err != nil {
return err
}
// We need to define the tool in the skill body (usually README.md or similar, but goskills parses skill.yaml and other files)
// Wait, goskills parses the "Body" from somewhere.
// Let's look at goskills.ParseSkillPackages implementation or docs if available.
// Based on runner.go, it seems to use `ParseSkillPackages`.
// Let's assume a simple structure.
// Actually, goskills uses `skill.yaml` and maybe other files.
// Let's create a `tools.json` or similar if goskills supports it, OR just rely on the fact that `goskills` might auto-detect scripts?
// `GenerateToolDefinitions` in `goskills` scans for scripts.
return nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/chat_agent/main.go | examples/chat_agent/main.go | package main
import (
"context"
"fmt"
"log"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/tmc/langchaingo/llms/openai"
)
func main() {
fmt.Println("=== ChatAgent Multi-Turn Conversation Demo ===")
fmt.Println()
llm, err := openai.New()
if err != nil {
log.Fatal(err)
}
// Create ChatAgent with no tools
agent, err := prebuilt.NewChatAgent(llm, nil)
if err != nil {
log.Fatalf("Failed to create ChatAgent: %v", err)
}
ctx := context.Background()
// Display session ID
fmt.Printf("Session ID: %s\n\n", agent.ThreadID())
// Turn 1: Greeting
fmt.Println("User: Hello!")
resp1, err := agent.Chat(ctx, "Hello!")
if err != nil {
log.Fatalf("Chat error: %v", err)
}
fmt.Printf("Agent: %s\n\n", resp1)
// Turn 2: Introduce name
fmt.Println("User: My name is Alice")
resp2, err := agent.Chat(ctx, "My name is Alice")
if err != nil {
log.Fatalf("Chat error: %v", err)
}
fmt.Printf("Agent: %s\n\n", resp2)
// Turn 3: Ask agent to recall name (testing memory)
fmt.Println("User: What's my name?")
resp3, err := agent.Chat(ctx, "What's my name?")
if err != nil {
log.Fatalf("Chat error: %v", err)
}
fmt.Printf("Agent: %s\n\n", resp3)
// Turn 4: Another question
fmt.Println("User: How many messages have we exchanged?")
resp4, err := agent.Chat(ctx, "How many messages have we exchanged?")
if err != nil {
log.Fatalf("Chat error: %v", err)
}
fmt.Printf("Agent: %s\n\n", resp4)
fmt.Println("=== Conversation Complete ===")
fmt.Printf("\nThis demo shows that ChatAgent maintains conversation history across multiple turns.\n")
fmt.Printf("The agent can reference previous messages (like your name) in later responses.\n")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/rag_advanced/main.go | examples/rag_advanced/main.go | package main
import (
"context"
"fmt"
"log"
"strings"
"github.com/smallnest/langgraphgo/graph"
"github.com/smallnest/langgraphgo/rag"
"github.com/smallnest/langgraphgo/rag/retriever"
"github.com/smallnest/langgraphgo/rag/splitter"
"github.com/smallnest/langgraphgo/rag/store"
"github.com/tmc/langchaingo/llms/openai"
)
func main() {
ctx := context.Background()
fmt.Println("Initializing LLM...")
// Initialize LLM
llm, err := openai.New()
if err != nil {
log.Fatalf("Failed to create LLM: %v", err)
}
fmt.Println("LLM Initialized.")
// Create a larger document corpus
documents := []rag.Document{
{
Content: "LangGraph is a library for building stateful, multi-actor applications with LLMs. " +
"It extends LangChain Expression Language with the ability to coordinate multiple chains " +
"across multiple steps of computation in a cyclic manner. LangGraph is particularly useful " +
"for building complex agent workflows and multi-agent systems.",
Metadata: map[string]any{
"source": "langgraph_intro.txt",
"topic": "LangGraph",
"category": "Framework",
},
},
{
Content: "RAG (Retrieval-Augmented Generation) is a technique that combines information retrieval " +
"with text generation. It retrieves relevant documents from a knowledge base and uses them " +
"to augment the context provided to a language model for generation. This approach helps " +
"reduce hallucinations and provides more factual, grounded responses.",
Metadata: map[string]any{
"source": "rag_overview.txt",
"topic": "RAG",
"category": "Technique",
},
},
{
Content: "Vector databases store embeddings, which are numerical representations of text. " +
"They enable efficient similarity search by comparing vector distances using metrics like " +
"cosine similarity or Euclidean distance. Popular vector databases include Pinecone, Weaviate, " +
"Chroma, and Qdrant. These databases are essential for RAG systems.",
Metadata: map[string]any{
"source": "vector_db.txt",
"topic": "Vector Databases",
"category": "Infrastructure",
},
},
{
Content: "Text embeddings are dense vector representations of text that capture semantic meaning. " +
"Models like OpenAI's text-embedding-ada-002, sentence transformers, or Cohere embeddings " +
"can generate these embeddings. Similar texts have similar embeddings in the vector space, " +
"which enables semantic search.",
Metadata: map[string]any{
"source": "embeddings.txt",
"topic": "Embeddings",
"category": "Technique",
},
},
{
Content: "Document reranking is a technique to improve retrieval quality by re-scoring retrieved " +
"documents based on their relevance to the query. Cross-encoder models are often used for " +
"reranking as they can better capture query-document interactions compared to bi-encoders " +
"used for initial retrieval.",
Metadata: map[string]any{
"source": "reranking.txt",
"topic": "Reranking",
"category": "Technique",
},
},
{
Content: "Multi-agent systems involve multiple AI agents working together to solve complex problems. " +
"Each agent can have specialized roles and capabilities. LangGraph provides excellent support " +
"for building multi-agent systems with its graph-based architecture and state management.",
Metadata: map[string]any{
"source": "multi_agent.txt",
"topic": "Multi-Agent",
"category": "Architecture",
},
},
}
// Split documents into smaller chunks
splitter := splitter.NewSimpleTextSplitter(200, 50)
chunks := splitter.SplitDocuments(documents)
fmt.Printf("Split %d documents into %d chunks\n\n", len(documents), len(chunks))
// Create embedder and vector store
embedder := store.NewMockEmbedder(256) // Higher dimension for better quality
vectorStore := store.NewInMemoryVectorStore(embedder)
// Generate embeddings and add chunks to vector store
texts := make([]string, len(chunks))
for i, chunk := range chunks {
texts[i] = chunk.Content
}
embeddings, err := embedder.EmbedDocuments(ctx, texts)
if err != nil {
log.Fatalf("Failed to generate embeddings: %v", err)
}
err = vectorStore.AddBatch(ctx, chunks, embeddings)
if err != nil {
log.Fatalf("Failed to add documents to vector store: %v", err)
}
// Create retriever and reranker
retriever := retriever.NewVectorStoreRetriever(vectorStore, embedder, 5)
reranker := store.NewSimpleReranker()
// Configure advanced RAG pipeline with reranking and citations
config := rag.DefaultPipelineConfig()
config.Retriever = retriever
config.Reranker = reranker
config.LLM = llm
config.TopK = 5
config.UseReranking = true
config.IncludeCitations = true
config.SystemPrompt = "You are a knowledgeable AI assistant. Answer questions based on the provided context. " +
"Always cite your sources using the document numbers provided. If the context doesn't contain " +
"enough information, acknowledge the limitations and provide what you can."
// Build advanced RAG pipeline
pipeline := rag.NewRAGPipeline(config)
err = pipeline.BuildAdvancedRAG()
if err != nil {
log.Fatalf("Failed to build advanced RAG pipeline: %v", err)
}
// Compile the pipeline
runnable, err := pipeline.Compile()
if err != nil {
log.Fatalf("Failed to compile pipeline: %v", err)
}
// Visualize the pipeline
exporter := graph.GetGraphForRunnable(runnable)
fmt.Println("=== Advanced RAG Pipeline Visualization (Mermaid) ===")
fmt.Println(exporter.DrawMermaid())
fmt.Println()
// Test queries with more complex questions
queries := []string{
"What is LangGraph and how is it used in multi-agent systems?",
"Explain the RAG technique and its benefits",
"What role do vector databases play in RAG systems?",
"How does document reranking improve retrieval quality?",
}
for i, query := range queries {
fmt.Printf("=== Query %d ===\n", i+1)
fmt.Printf("Question: %s\n\n", query)
result, err := runnable.Invoke(ctx, map[string]any{
"query": query,
})
if err != nil {
log.Printf("Failed to process query: %v", err)
continue
}
finalState := result
fmt.Println("Retrieved and Reranked Documents:")
if docs, ok := finalState["documents"].([]rag.RAGDocument); ok {
for j, doc := range docs {
source := "Unknown"
if s, ok := doc.Metadata["source"]; ok {
source = fmt.Sprintf("%v", s)
}
category := "N/A"
if c, ok := doc.Metadata["category"]; ok {
category = fmt.Sprintf("%v", c)
}
fmt.Printf(" [%d] %s (Category: %s)\n", j+1, source, category)
fmt.Printf(" %s\n", truncate(doc.Content, 120))
}
}
if rankedDocs, ok := finalState["ranked_documents"].([]rag.DocumentSearchResult); ok {
if len(rankedDocs) > 0 {
fmt.Printf("\nRelevance Scores:\n")
for j, rd := range rankedDocs {
if j >= 3 {
break // Show top 3 scores
}
fmt.Printf(" [%d] Score: %.4f\n", j+1, rd.Score)
}
}
}
if answer, ok := finalState["answer"].(string); ok {
fmt.Printf("\nAnswer: %s\n", answer)
}
if citations, ok := finalState["citations"].([]string); ok {
if len(citations) > 0 {
fmt.Println("\nCitations:")
for _, citation := range citations {
fmt.Printf(" %s\n", citation)
}
}
}
fmt.Println("\n" + strings.Repeat("=", 100) + "\n")
}
}
func truncate(s string, maxLen int) string {
if len(s) <= maxLen {
return s
}
return s[:maxLen] + "..."
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/rag_pipeline/main.go | examples/rag_pipeline/main.go | package main
import (
"context"
"fmt"
"log"
"os"
"github.com/smallnest/langgraphgo/graph"
"github.com/smallnest/langgraphgo/rag"
"github.com/smallnest/langgraphgo/rag/retriever"
"github.com/smallnest/langgraphgo/rag/store"
"github.com/tmc/langchaingo/llms/openai"
)
func main() {
// Check for OpenAI API key
if os.Getenv("OPENAI_API_KEY") == "" {
fmt.Println("OPENAI_API_KEY not set. Skipping execution.")
return
}
ctx := context.Background()
// Initialize LLM
llm, err := openai.New()
if err != nil {
log.Fatalf("Failed to create LLM: %v", err)
}
// Create sample documents
documents := []rag.Document{
{
Content: "LangGraph is a library for building stateful, multi-actor applications with LLMs.",
Metadata: map[string]any{"source": "docs"},
},
{
Content: "RAG (Retrieval-Augmented Generation) combines retrieval with generation.",
Metadata: map[string]any{"source": "docs"},
},
}
// Create embedder and vector store
embedder := store.NewMockEmbedder(128)
vectorStore := store.NewInMemoryVectorStore(embedder)
// Add documents
texts := make([]string, len(documents))
for i, doc := range documents {
texts[i] = doc.Content
}
embeddings, _ := embedder.EmbedDocuments(ctx, texts)
vectorStore.AddBatch(ctx, documents, embeddings)
// Create retriever
retriever := retriever.NewVectorStoreRetriever(vectorStore, embedder, 2)
// Configure RAG pipeline
config := rag.DefaultPipelineConfig()
config.Retriever = retriever
config.LLM = llm
// Build basic RAG pipeline
pipeline := rag.NewRAGPipeline(config)
err = pipeline.BuildBasicRAG()
if err != nil {
log.Fatalf("Failed to build RAG pipeline: %v", err)
}
// Compile the pipeline
runnable, err := pipeline.Compile()
if err != nil {
log.Fatalf("Failed to compile pipeline: %v", err)
}
// Visualize
exporter := graph.GetGraphForRunnable(runnable)
fmt.Println("Pipeline Structure:")
fmt.Println(exporter.DrawASCII())
// Run query
query := "What is LangGraph?"
fmt.Printf("\nQuery: %s\n", query)
result, err := runnable.Invoke(ctx, map[string]any{
"query": query,
})
if err != nil {
log.Fatalf("Failed to process query: %v", err)
}
if answer, ok := result["answer"].(string); ok {
fmt.Printf("Answer: %s\n", answer)
}
if docs, ok := result["documents"].([]rag.RAGDocument); ok {
fmt.Printf("Retrieved %d documents\n", len(docs))
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/tool_exa/main.go | examples/tool_exa/main.go | package main
import (
"context"
"fmt"
"log"
"os"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/smallnest/langgraphgo/tool"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
"github.com/tmc/langchaingo/tools"
)
func main() {
// Check for API keys
if os.Getenv("EXA_API_KEY") == "" {
log.Fatal("Please set EXA_API_KEY environment variable")
}
if os.Getenv("OPENAI_API_KEY") == "" && os.Getenv("DEEPSEEK_API_KEY") == "" {
log.Fatal("Please set OPENAI_API_KEY or DEEPSEEK_API_KEY environment variable")
}
ctx := context.Background()
// 1. Initialize the LLM
llm, err := openai.New()
if err != nil {
log.Fatalf("Failed to create LLM: %v", err)
}
// 2. Initialize the Tool
exaTool, err := tool.NewExaSearch("",
tool.WithExaNumResults(5),
)
if err != nil {
log.Fatal(err)
}
// 3. Create the ReAct Agent using map state convenience function
agent, err := prebuilt.CreateAgentMap(llm, []tools.Tool{exaTool}, 20)
if err != nil {
log.Fatalf("Failed to create agent: %v", err)
}
// 4. Run the Agent
query := "Latest news about SpaceX Starship in 2025"
fmt.Printf("User: %s\n\n", query)
inputs := map[string]any{
"messages": []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeHuman, query),
},
}
response, err := agent.Invoke(ctx, inputs)
if err != nil {
log.Fatalf("Agent failed: %v", err)
}
// 5. Print the Result
messages, ok := response["messages"].([]llms.MessageContent)
if ok {
lastMsg := messages[len(messages)-1]
for _, part := range lastMsg.Parts {
if text, ok := part.(llms.TextContent); ok {
fmt.Printf("\nAgent: %s\n", text.Text)
}
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/create_agent/main.go | examples/create_agent/main.go | package main
import (
"context"
"fmt"
"log"
"os"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
"github.com/tmc/langchaingo/tools"
)
// WeatherTool is a simple tool to get weather
type WeatherTool struct{}
func (t *WeatherTool) Name() string {
return "get_weather"
}
func (t *WeatherTool) Description() string {
return "Get the weather for a city"
}
func (t *WeatherTool) Call(ctx context.Context, input string) (string, error) {
return fmt.Sprintf("The weather in %s is sunny and 25°C", input), nil
}
func main() {
// Check if OPENAI_API_KEY is set
if os.Getenv("OPENAI_API_KEY") == "" {
log.Println("OPENAI_API_KEY not set, skipping example execution")
return
}
ctx := context.Background()
// Initialize LLM
model, err := openai.New()
if err != nil {
log.Fatalf("Failed to create LLM: %v", err)
}
// Define tools
inputTools := []tools.Tool{&WeatherTool{}}
// Create agent with options using CreateAgentMap
agent, err := prebuilt.CreateAgentMap(model, inputTools, 0,
prebuilt.WithSystemMessage("You are a helpful weather assistant. Always be polite."),
prebuilt.WithStateModifier(func(msgs []llms.MessageContent) []llms.MessageContent {
// Example modifier: Log the number of messages
log.Printf("Current message count: %d", len(msgs))
return msgs
}),
)
if err != nil {
log.Fatalf("Failed to create agent: %v", err)
}
// Initial input
inputs := map[string]any{
"messages": []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeHuman, "What is the weather in San Francisco?"),
},
}
// Run the agent
log.Println("Starting agent...")
result, err := agent.Invoke(ctx, inputs)
if err != nil {
log.Fatalf("Agent execution failed: %v", err)
}
// Print result
messages := result["messages"].([]llms.MessageContent)
lastMsg := messages[len(messages)-1]
for _, part := range lastMsg.Parts {
switch p := part.(type) {
case llms.TextContent:
fmt.Printf("Agent Response: %s\n", p.Text)
case llms.ToolCall:
fmt.Printf("Tool Call: %s\n", p.FunctionCall.Name)
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/reflexive_metacognitive_cn/main.go | examples/reflexive_metacognitive_cn/main.go | // Reflexive Metacognitive Agent (Chinese Version)
// 这是一个实现 Fareed Khan 的 Agentic Architectures 系列中的“反思性元认知 Agent”架构的示例。
package main
import (
"context"
"fmt"
"log"
"os"
"strings"
"github.com/smallnest/langgraphgo/graph"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
)
// ==================== 数据模型 ====================
type AgentSelfModel struct {
Name string
Role string
KnowledgeDomain []string
AvailableTools []string
ConfidenceThreshold float64
}
type MetacognitiveAnalysis struct {
Confidence float64
Strategy string
Reasoning string
ToolToUse string
ToolArgs map[string]string
}
type AgentState struct {
UserQuery string
SelfModel *AgentSelfModel
MetacognitiveAnalysis *MetacognitiveAnalysis
ToolOutput string
FinalResponse string
}
// ==================== 工具 ====================
type DrugInteractionChecker struct {
knownInteractions map[string]string
}
func (d *DrugInteractionChecker) Check(drugA, drugB string) string {
key := drugA + "+" + drugB
if interaction, ok := d.knownInteractions[key]; ok {
return fmt.Sprintf("发现相互作用：%s", interaction)
}
return "未发现明显的相互作用。但请务必咨询医生。"
}
func NewDrugInteractionChecker() *DrugInteractionChecker {
return &DrugInteractionChecker{
knownInteractions: map[string]string{
"布洛芬+利辛诺普利": "中度风险：布洛芬可能会降低利辛诺普利的降压效果。请监测血压。",
"阿司匹林+华法林": "高风险：增加出血风险。除非医生指导，否则应避免这种组合。",
},
}
}
var drugTool = NewDrugInteractionChecker()
// ==================== 图节点 ====================
func MetacognitiveAnalysisNode(ctx context.Context, state map[string]any) (map[string]any, error) {
agentState := state["agent_state"].(*AgentState)
fmt.Println("\n--- 🤔 Agent 正在进行元认知分析... ---")
prompt := fmt.Sprintf(`你是 AI 助手的元认知推理引擎。你的任务是根据 Agent 的自我模型分析用户的查询。
**Agent 自我模型：**
- 名称：%s
- 角色：%s
- 知识领域：%s
- 可用工具：%s
**策略规则：**
1. **escalate (上报)**：涉及紧急情况、不在知识领域内或有任何疑虑。
2. **use_tool (使用工具)**：需要使用 'drug_interaction_checker'。
3. **reason_directly (直接回答)**：在知识领域内且风险较低。
格式：
CONFIDENCE: [0.0 到 1.0]
STRATEGY: [escalate|use_tool|reason_directly]
TOOL_TO_USE: [工具名称或 "none"]
DRUG_A: [药物 A 名称或 "none"]
DRUG_B: [药物 B 名称 or "none"]
REASONING: [简要理由]
**用户查询：** %s`,
agentState.SelfModel.Name,
agentState.SelfModel.Role,
strings.Join(agentState.SelfModel.KnowledgeDomain, ", "),
strings.Join(agentState.SelfModel.AvailableTools, ", "),
agentState.UserQuery)
llm := state["llm"].(llms.Model)
resp, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
if err != nil {
return nil, fmt.Errorf("元认知分析调用失败: %w", err)
}
analysis := parseMetacognitiveAnalysis(resp)
agentState.MetacognitiveAnalysis = analysis
fmt.Printf("置信度: %.2f | 策略: %s\n", analysis.Confidence, analysis.Strategy)
return state, nil
}
func ReasonDirectlyNode(ctx context.Context, state map[string]any) (map[string]any, error) {
agentState := state["agent_state"].(*AgentState)
fmt.Println("--- ✅ 直接回答中... ---")
prompt := fmt.Sprintf(`你是 %s。请提供一个有用的、非处方性的回答。提醒：你不是医生。
查询：%s`, agentState.SelfModel.Role, agentState.UserQuery)
llm := state["llm"].(llms.Model)
resp, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
if err != nil {
return nil, err
}
agentState.FinalResponse = resp
return state, nil
}
func CallToolNode(ctx context.Context, state map[string]any) (map[string]any, error) {
agentState := state["agent_state"].(*AgentState)
fmt.Printf("--- 🛠️ 调用工具 `%s`... ---\n", agentState.MetacognitiveAnalysis.ToolToUse)
analysis := agentState.MetacognitiveAnalysis
if analysis.ToolToUse == "drug_interaction_checker" {
agentState.ToolOutput = drugTool.Check(analysis.ToolArgs["drug_a"], analysis.ToolArgs["drug_b"])
} else {
agentState.ToolOutput = "错误：未找到工具。"
}
return state, nil
}
func SynthesizeToolResponseNode(ctx context.Context, state map[string]any) (map[string]any, error) {
agentState := state["agent_state"].(*AgentState)
fmt.Println("--- 📝 综合工具输出... ---")
prompt := fmt.Sprintf(`你是 %s。请结合工具输出向用户提供帮助。务必声明你不是医生。
查询：%s
工具输出：%s`, agentState.SelfModel.Role, agentState.UserQuery, agentState.ToolOutput)
llm := state["llm"].(llms.Model)
resp, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
if err != nil {
return nil, err
}
agentState.FinalResponse = resp
return state, nil
}
func EscalateToHumanNode(ctx context.Context, state map[string]any) (map[string]any, error) {
agentState := state["agent_state"].(*AgentState)
fmt.Println("--- 🚨 风险较高，正在上报... ---")
agentState.FinalResponse = "我是 AI 助手，不具备提供此话题相关信息的资质。**请立即咨询医疗专业人员。**"
return state, nil
}
func RouteStrategy(ctx context.Context, state map[string]any) string {
agentState := state["agent_state"].(*AgentState)
switch agentState.MetacognitiveAnalysis.Strategy {
case "reason_directly":
return "reason"
case "use_tool":
return "call_tool"
default:
return "escalate"
}
}
func parseMetacognitiveAnalysis(response string) *MetacognitiveAnalysis {
analysis := &MetacognitiveAnalysis{Confidence: 0.1, Strategy: "escalate", ToolArgs: make(map[string]string)}
lines := strings.Split(response, "\n")
for _, line := range lines {
line = strings.TrimSpace(line)
parts := strings.SplitN(line, ":", 2)
if len(parts) < 2 {
continue
}
key := strings.ToUpper(strings.TrimSpace(parts[0]))
val := strings.TrimSpace(parts[1])
switch key {
case "CONFIDENCE":
fmt.Sscanf(val, "%f", &analysis.Confidence)
case "STRATEGY":
analysis.Strategy = strings.ToLower(val)
case "TOOL_TO_USE":
analysis.ToolToUse = strings.ToLower(val)
case "DRUG_A":
analysis.ToolArgs["drug_a"] = val
case "DRUG_B":
analysis.ToolArgs["drug_b"] = val
case "REASONING":
analysis.Reasoning = val
}
}
return analysis
}
func main() {
if os.Getenv("OPENAI_API_KEY") == "" {
log.Fatal("请设置 OPENAI_API_KEY")
}
llm, err := openai.New()
if err != nil {
log.Fatal(err)
}
medicalAgentModel := &AgentSelfModel{
Name: "分诊机器人-3000",
Role: "提供初步医疗信息的 AI 助手",
KnowledgeDomain: []string{"感冒", "流感", "过敏", "头痛", "急救"},
AvailableTools: []string{"drug_interaction_checker"},
ConfidenceThreshold: 0.6,
}
workflow := graph.NewStateGraph[map[string]any]()
workflow.AddNode("analyze", "元认知分析", MetacognitiveAnalysisNode)
workflow.AddNode("reason", "直接回答", ReasonDirectlyNode)
workflow.AddNode("call_tool", "调用工具", CallToolNode)
workflow.AddNode("synthesize", "综合输出", SynthesizeToolResponseNode)
workflow.AddNode("escalate", "上报", EscalateToHumanNode)
workflow.SetEntryPoint("analyze")
workflow.AddConditionalEdge("analyze", RouteStrategy)
workflow.AddEdge("reason", graph.END)
workflow.AddEdge("call_tool", "synthesize")
workflow.AddEdge("synthesize", graph.END)
workflow.AddEdge("escalate", graph.END)
app, err := workflow.Compile()
if err != nil {
log.Fatal(err)
}
fmt.Println("--- 测试：查询感冒症状 ---")
agentState := &AgentState{UserQuery: "感冒有哪些症状？", SelfModel: medicalAgentModel}
result, _ := app.Invoke(context.Background(), map[string]any{"llm": llm, "agent_state": agentState})
fmt.Printf("\n回答：%s\n", result["agent_state"].(*AgentState).FinalResponse)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/mcp_agent/main.go | examples/mcp_agent/main.go | package main
import (
"context"
"fmt"
"log"
"os"
"path/filepath"
"github.com/smallnest/langgraphgo/adapter/mcp"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
)
func main() {
ctx := context.Background()
// 1. Create MCP client from Claude's config file
projectRoot := ".."
configPath := filepath.Join(projectRoot, "testdata", "mcp", "mcp.json")
mcpClient, err := mcp.NewClientFromConfig(ctx, configPath)
if err != nil {
log.Fatalf("Failed to create MCP client: %v\n", err)
}
defer mcpClient.Close()
// 2. Convert MCP tools to langchaingo tools
tools, err := mcp.MCPToTools(ctx, mcpClient)
if err != nil {
log.Fatalf("Failed to get MCP tools: %v\n", err)
}
fmt.Printf("Loaded %d MCP tools:\n", len(tools))
for _, tool := range tools {
fmt.Printf(" - %s: %s\n", tool.Name(), tool.Description())
}
// 3. Create OpenAI LLM
apiKey := os.Getenv("OPENAI_API_KEY")
if apiKey == "" {
log.Fatal("OPENAI_API_KEY environment variable is required")
}
llm, err := openai.New()
if err != nil {
log.Fatalf("Failed to create LLM: %v\n", err)
}
// 4. Create agent with MCP tools using CreateAgentMap
agent, err := prebuilt.CreateAgentMap(
llm,
tools,
0,
prebuilt.WithSystemMessage("You are a helpful assistant with access to various tools through MCP. Use them to help answer questions."),
)
if err != nil {
log.Fatalf("Failed to create agent: %v\n", err)
}
// 5. Test the agent with a query
query := "What files are in the current directory?"
fmt.Printf("\nQuery: %s\n", query)
// Prepare initial state with messages
initialState := map[string]any{
"messages": []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeHuman, query),
},
}
result, err := agent.Invoke(ctx, initialState)
if err != nil {
log.Fatalf("Failed to invoke agent: %v\n", err)
}
// 6. Print the result
// Result is map[string]any
if messages, ok := result["messages"]; ok {
fmt.Printf("\nAgent messages:\n%+v\n", messages)
} else {
fmt.Printf("\nAgent result:\n%+v\n", result)
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/dynamic_skill_agent/main.go | examples/dynamic_skill_agent/main.go | package main
import (
"context"
"fmt"
"log"
"os"
"github.com/smallnest/langgraphgo/prebuilt"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/llms/openai"
"github.com/tmc/langchaingo/tools"
)
func main() {
// 1. Initialize LLM
if os.Getenv("OPENAI_API_KEY") == "" {
log.Fatal("OPENAI_API_KEY is not set")
}
llm, err := openai.New()
if err != nil {
log.Fatal(err)
}
// 2. Setup Skills Directory
skillsDir := "skills"
if _, err := os.Stat(skillsDir); os.IsNotExist(err) {
err = createDummySkill(skillsDir)
if err != nil {
log.Fatal(err)
}
defer os.RemoveAll(skillsDir)
}
// 3. Create Agent with Skill Selection
// We pass an empty list of initial tools, as we rely on dynamic skill selection
agent, err := prebuilt.CreateAgentMap(llm, []tools.Tool{}, 0,
prebuilt.WithSkillDir(skillsDir),
prebuilt.WithVerbose(true),
prebuilt.WithSystemMessage("You are a helpful assistant."),
)
if err != nil {
log.Fatal(err)
}
// 4. Run Agent
ctx := context.Background()
// Input that should trigger the hello_world skill
input := "Please run the hello world script."
fmt.Println("User:", input)
resp, err := agent.Invoke(ctx, map[string]any{
"messages": []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeHuman, input),
},
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Agent Response: %v\n", resp)
}
func createDummySkill(dir string) error {
err := os.MkdirAll(dir+"/hello_world", 0755)
if err != nil {
return err
}
meta := `---
name: hello_world
description: A skill that prints hello world.
version: 1.0.0
---
## Usage
` + "```python" + `
scripts/hello.py
` + "```" + `
`
err = os.WriteFile(dir+"/hello_world/SKILL.md", []byte(meta), 0644)
if err != nil {
return err
}
script := `
print("Hello, World from Python Skill!")
`
err = os.MkdirAll(dir+"/hello_world/scripts", 0755)
if err != nil {
return err
}
err = os.WriteFile(dir+"/hello_world/scripts/hello.py", []byte(script), 0644)
if err != nil {
return err
}
return nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/examples/listeners/main.go | examples/listeners/main.go | package main
import (
"context"
"fmt"
"time"
"github.com/smallnest/langgraphgo/graph"
)
func main() {
// Create a listenable graph
g := graph.NewListenableStateGraph[map[string]any]()
// Define nodes
processNode := g.AddNode("process", "process", func(ctx context.Context, state map[string]any) (map[string]any, error) {
time.Sleep(100 * time.Millisecond)
return map[string]any{"processed": true}, nil
})
analyzeNode := g.AddNode("analyze", "analyze", func(ctx context.Context, state map[string]any) (map[string]any, error) {
time.Sleep(100 * time.Millisecond)
return map[string]any{"analyzed": true}, nil
})
reportNode := g.AddNode("report", "report", func(ctx context.Context, state map[string]any) (map[string]any, error) {
time.Sleep(100 * time.Millisecond)
return map[string]any{"reported": true}, nil
})
// Add global listener (logs everything)
g.AddGlobalListener(graph.NewLoggingListener().WithLogLevel(graph.LogLevelInfo))
// Add specific listener to process node (metrics)
processNode.AddListener(graph.NewMetricsListener())
// Add listener to analyze node
analyzeNode.AddListener(graph.NewLoggingListener().WithLogLevel(graph.LogLevelDebug))
// Add progress listener to report node
reportNode.AddListener(graph.NewProgressListener().WithPrefix("📊"))
// Define flow
g.SetEntryPoint("process")
g.AddEdge("process", "analyze")
g.AddEdge("analyze", "report")
g.AddEdge("report", graph.END)
// Compile
runnable, err := g.CompileListenable()
if err != nil {
panic(err)
}
// Run
fmt.Println("Running graph with listeners...")
_, err = runnable.Invoke(context.Background(), map[string]any{})
if err != nil {
panic(err)
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/llm_adapter_test.go | adapter/llm_adapter_test.go | package adapter
import (
"context"
"errors"
"testing"
"github.com/tmc/langchaingo/llms"
)
// mockLLM is a mock implementation of llms.Model for testing
type mockLLM struct {
generateResponse string
generateError error
generateContentResult *llms.ContentResponse
generateContentError error
calls []mockCall
}
type mockCall struct {
method string
prompt string
}
func (m *mockLLM) GenerateContent(ctx context.Context, messages []llms.MessageContent, options ...llms.CallOption) (*llms.ContentResponse, error) {
// Check for context cancellation
select {
case <-ctx.Done():
return nil, ctx.Err()
default:
}
m.calls = append(m.calls, mockCall{method: "GenerateContent", prompt: messages[0].Parts[0].(llms.TextContent).Text})
if m.generateContentError != nil {
return nil, m.generateContentError
}
if m.generateContentResult != nil {
return m.generateContentResult, nil
}
return &llms.ContentResponse{
Choices: []*llms.ContentChoice{
{
Content: m.generateResponse,
},
},
}, nil
}
func (m *mockLLM) Call(ctx context.Context, prompt string, options ...llms.CallOption) (string, error) {
// Check for context cancellation
select {
case <-ctx.Done():
return "", ctx.Err()
default:
}
m.calls = append(m.calls, mockCall{method: "Call", prompt: prompt})
if m.generateError != nil {
return "", m.generateError
}
return m.generateResponse, nil
}
func (m *mockLLM) GetNumTokens(text string) int {
return len(text) // Simplified token count
}
func TestNewOpenAIAdapter(t *testing.T) {
llm := &mockLLM{generateResponse: "test"}
adapter := NewOpenAIAdapter(llm)
if adapter == nil {
t.Fatal("NewOpenAIAdapter returned nil")
}
if adapter.llm != llm {
t.Error("adapter.llm is not the same as the provided llm")
}
}
func TestOpenAIAdapter_Generate(t *testing.T) {
tests := []struct {
name string
prompt string
response string
expectedResult string
}{
{
name: "successful generation",
prompt: "Hello, world!",
response: "Hello! How can I help you?",
expectedResult: "Hello! How can I help you?",
},
{
name: "empty prompt",
prompt: "",
response: "Empty response",
expectedResult: "Empty response",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
llm := &mockLLM{generateResponse: tt.response}
adapter := NewOpenAIAdapter(llm)
ctx := context.Background()
result, err := adapter.Generate(ctx, tt.prompt)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if result != tt.expectedResult {
t.Errorf("expected %q, got %q", tt.expectedResult, result)
}
})
}
}
func TestOpenAIAdapter_GenerateWithConfig(t *testing.T) {
tests := []struct {
name string
prompt string
config map[string]any
response string
expectedResult string
}{
{
name: "no config",
prompt: "Test prompt",
config: nil,
response: "Response",
expectedResult: "Response",
},
{
name: "with temperature",
prompt: "Test prompt",
config: map[string]any{"temperature": 0.7},
response: "Response with temp",
expectedResult: "Response with temp",
},
{
name: "with max_tokens",
prompt: "Test prompt",
config: map[string]any{"max_tokens": 100},
response: "Response with max tokens",
expectedResult: "Response with max tokens",
},
{
name: "with temperature and max_tokens",
prompt: "Test prompt",
config: map[string]any{"temperature": 0.5, "max_tokens": 200},
response: "Response with both",
expectedResult: "Response with both",
},
{
name: "with invalid temperature type (ignored)",
prompt: "Test prompt",
config: map[string]any{"temperature": "invalid"},
response: "Response",
expectedResult: "Response",
},
{
name: "with invalid max_tokens type (ignored)",
prompt: "Test prompt",
config: map[string]any{"max_tokens": "invalid"},
response: "Response",
expectedResult: "Response",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
llm := &mockLLM{generateResponse: tt.response}
adapter := NewOpenAIAdapter(llm)
ctx := context.Background()
result, err := adapter.GenerateWithConfig(ctx, tt.prompt, tt.config)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if result != tt.expectedResult {
t.Errorf("expected %q, got %q", tt.expectedResult, result)
}
})
}
}
func TestOpenAIAdapter_GenerateWithSystem(t *testing.T) {
tests := []struct {
name string
system string
prompt string
response *llms.ContentResponse
err error
expectedResult string
expectedErr bool
}{
{
name: "successful generation with system prompt",
system: "You are a helpful assistant.",
prompt: "Hello!",
response: &llms.ContentResponse{
Choices: []*llms.ContentChoice{
{Content: "Hello! How can I assist you today?"},
},
},
expectedResult: "Hello! How can I assist you today?",
expectedErr: false,
},
{
name: "empty system and prompt",
system: "",
prompt: "",
response: &llms.ContentResponse{
Choices: []*llms.ContentChoice{
{Content: "OK"},
},
},
expectedResult: "OK",
expectedErr: false,
},
{
name: "LLM error",
system: "You are helpful.",
prompt: "Test",
err: errors.New("generation error"),
expectedResult: "",
expectedErr: true,
},
{
name: "empty choices returns empty string",
system: "You are helpful.",
prompt: "Test",
response: &llms.ContentResponse{
Choices: []*llms.ContentChoice{},
},
expectedResult: "",
expectedErr: false,
},
{
name: "nil choices returns empty string",
system: "You are helpful.",
prompt: "Test",
response: &llms.ContentResponse{
Choices: nil,
},
expectedResult: "",
expectedErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
llm := &mockLLM{generateContentResult: tt.response, generateContentError: tt.err}
adapter := NewOpenAIAdapter(llm)
ctx := context.Background()
result, err := adapter.GenerateWithSystem(ctx, tt.system, tt.prompt)
if tt.expectedErr && err == nil {
t.Error("expected error but got nil")
}
if !tt.expectedErr && err != nil {
t.Errorf("unexpected error: %v", err)
}
if result != tt.expectedResult {
t.Errorf("expected %q, got %q", tt.expectedResult, result)
}
})
}
}
func TestOpenAIAdapter_ContextCancellation(t *testing.T) {
llm := &mockLLM{generateResponse: "response"}
adapter := NewOpenAIAdapter(llm)
ctx, cancel := context.WithCancel(context.Background())
cancel() // Cancel immediately
_, err := adapter.Generate(ctx, "test")
if err == nil {
t.Error("expected error due to context cancellation")
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/llm_adapter.go | adapter/llm_adapter.go | package adapter
import (
"context"
"github.com/tmc/langchaingo/llms"
)
// OpenAIAdapter adapts langchaingo's LLM to a simple interface
type OpenAIAdapter struct {
llm llms.Model
}
// NewOpenAIAdapter creates a new adapter for OpenAI LLM
func NewOpenAIAdapter(llm llms.Model) *OpenAIAdapter {
return &OpenAIAdapter{
llm: llm,
}
}
// Generate implements the simple generation interface
func (o *OpenAIAdapter) Generate(ctx context.Context, prompt string) (string, error) {
return llms.GenerateFromSinglePrompt(ctx, o.llm, prompt)
}
// GenerateWithConfig implements the simple generation interface with configuration
func (o *OpenAIAdapter) GenerateWithConfig(ctx context.Context, prompt string, config map[string]any) (string, error) {
var options []llms.CallOption
if temp, ok := config["temperature"].(float64); ok {
options = append(options, llms.WithTemperature(temp))
}
if maxTokens, ok := config["max_tokens"].(int); ok {
options = append(options, llms.WithMaxTokens(maxTokens))
}
return llms.GenerateFromSinglePrompt(ctx, o.llm, prompt, options...)
}
// GenerateWithSystem implements the simple generation interface with system prompt
func (o *OpenAIAdapter) GenerateWithSystem(ctx context.Context, system, prompt string) (string, error) {
// GenerateWithSystem involves multiple messages, so we use GenerateContent
response, err := o.llm.GenerateContent(ctx, []llms.MessageContent{
llms.TextParts(llms.ChatMessageTypeSystem, system),
llms.TextParts(llms.ChatMessageTypeHuman, prompt),
})
if err != nil {
return "", err
}
if len(response.Choices) > 0 {
return response.Choices[0].Content, nil
}
return "", nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/doc.go | adapter/doc.go | // Package adapter provides integration adapters for connecting LangGraph Go with external systems and frameworks.
//
// Adapters act as bridges between LangGraph's internal representations and external APIs,
// protocols, or frameworks. They enable seamless integration with a wide ecosystem of tools,
// services, and platforms without modifying the core LangGraph implementation.
//
// This package includes adapters for:
// - GoSkills: Custom Go-based skills and tools
// - MCP (Model Context Protocol): Standardized tool communication
//
// # Core Concepts
//
// ## Adapter Pattern
//
// Each adapter implements conversion between different representations:
// - LangChain tools → LangGraph tools
// - External protocols → Internal interfaces
// - Third-party APIs → Native functionality
//
// The adapters ensure type safety and provide consistent error handling while maintaining
// the flexibility to work with various external systems.
//
// ## Integration Approach
//
// Adapters in this package follow these principles:
// - Zero-configuration: Work out of the box with sensible defaults
// - Extensible: Allow customization for advanced use cases
// - Performant: Minimize overhead through efficient conversions
// - Compatible: Support standard protocols and formats
//
// # Available Adapters
//
// ## GoSkills Adapter (adapter/goskills)
//
// Integrates GoSkills framework for defining and executing Go-based skills:
//
// - Load Go skills from directories or repositories
// - Convert GoSkills to LangChain-compatible tools
// - Execute Go code in controlled environments
// - Support custom skill development
//
// Use Cases:
// - Custom business logic written in Go
// - High-performance native code execution
// - Integration with existing Go services
// - Type-safe tool implementations
//
// Example:
//
// import "github.com/smallnest/langgraphgo/adapter/goskills"
//
// // Load skills from directory
// skills, _ := goskills.LoadSkillsFromDir("./skills")
//
// // Convert to LangChain tools
// tools, _ := goskills.ConvertToLangChainTools(skills)
//
// // Use with ReAct agent
// agent, _ := prebuilt.CreateReactAgent(llm, tools, 10)
//
// ## MCP Adapter (adapter/mcp)
//
// Integrates with the Model Context Protocol for standardized tool communication:
//
// - Connect to MCP servers via various transports
// - Automatically discover available tools
// - Handle MCP protocol messages
// - Support real-time communication
//
// Use Cases:
// - Access to growing MCP tool ecosystem
// - Standardized tool interfaces
// - Cross-platform compatibility
// - Community-driven tool development
//
// Example:
//
// import "github.com/smallnest/langgraphgo/adapter/mcp"
//
// // Connect to MCP server
// client, _ := mcp.NewMCPClient("stdio", []string{"python", "mcp_server.py"})
//
// // List available tools
// tools, _ := client.ListTools()
//
// // Convert to LangChain tools
// langchainTools := make([]tools.Tool, len(tools))
// for i, t := range tools {
// langchainTools[i] = &mcp.MCPTool{
// name: t.Name,
// description: t.Description,
// client: client,
// }
// }
//
// # Usage Patterns
//
// ## Single Adapter Usage
//
// // Using only GoSkills
// goskillsTools, _ := goskills.ConvertToLangChainTools(skills)
// agent, _ := prebuilt.CreateReactAgent(llm, goskillsTools, 10)
//
// // Using only MCP
// mcpTools, _ := mcp.ConvertMCPTools(mcpClient)
// agent, _ := prebuilt.CreateReactAgent(llm, mcpTools, 10)
//
// ## Multiple Adapters
//
// Combine tools from multiple adapters:
//
// // Load tools from different sources
// var allTools []tools.Tool
//
// // GoSkills tools
// goskillsTools, _ := goskills.ConvertToLangChainSkills(goskills.Skills)
// allTools = append(allTools, goskillsTools...)
//
// // MCP tools
// mcpTools, _ := mcp.DiscoverTools(mcpServers...)
// allTools = append(allTools, mcpTools...)
//
// // Built-in tools
// builtinTools := []tools.Tool{&CalculatorTool{}, &WeatherTool{}}
// allTools = append(allTools, builtinTools...)
//
// // Create agent with all tools
// agent, _ := prebuilt.CreateReactAgent(llm, allTools, 20)
//
// # Adapter Configuration
//
// ## Adapter Options
//
// Most adapters support configuration through options:
//
// // GoSkills configuration
// goskillsConfig := goskills.Config{
// SkillPath: "./skills",
// WatchChanges: true,
// CacheResults: true,
// }
// goskillsAdapter, _ := goskills.NewAdapter(goskillsConfig)
//
// // MCP configuration
// mcpConfig := mcp.Config{
// Transport: "http",
// URL: "http://localhost:8080/mcp",
// Timeout: 30 * time.Second,
// RetryPolicy: mcp.ExponentialBackoff,
// }
// mcpAdapter, _ := mcp.NewAdapter(mcpConfig)
//
// ## Dynamic Adapter Loading
//
// // Load adapters based on configuration
// func LoadAdapters(config Config) ([]tools.Tool, error) {
// var tools []tools.Tool
//
// if config.GoSkills.Enabled {
// goskillsAdapter, _ := goskills.NewAdapter(config.GoSkills)
// tools = append(tools, goskillsAdapter.GetTools()...)
// }
//
// if config.MCP.Enabled {
// mcpAdapter, _ := mcp.NewAdapter(config.MCP)
// tools = append(tools, mcpAdapter.GetTools()...)
// }
//
// return tools, nil
// }
//
// # Performance Considerations
//
// ## Adapter Overhead
//
// Adapters add minimal overhead, but consider:
// - Lazy loading of adapters
// - Caching of converted tools
// - Connection pooling for remote adapters
// - Batching operations where possible
//
// Example optimization:
//
// type CachedAdapter struct {
// tools []tools.Tool
// mutex sync.RWMutex
// cache map[string]tools.Tool
// }
//
// func (a *CachedAdapter) GetTool(name string) (tools.Tool, error) {
// a.mutex.RLock()
// if tool, exists := a.cache[name]; exists {
// a.mutex.RUnlock()
// return tool, nil
// }
// a.mutex.RUnlock()
//
// // Load tool and cache
// tool, err := a.loadTool(name)
// if err != nil {
// return nil, err
// }
//
// a.mutex.Lock()
// a.cache[name] = tool
// a.mutex.Unlock()
//
// return tool, nil
// }
//
// # Error Handling
//
// Adapters provide consistent error handling:
//
// // Adapter-specific errors
// type AdapterError struct {
// Adapter string
// Tool string
// Cause error
// }
//
// func (e *AdapterError) Error() string {
// return fmt.Sprintf("adapter %s: tool %s: %v", e.Adapter, e.Tool, e.Cause)
// }
//
// // Recover from adapter errors
// func handleAdapterError(err error) error {
// if adapterErr, ok := err.(*AdapterError); ok {
// // Log and continue with other tools
// log.Printf("Adapter error: %v", adapterErr)
// return nil
// }
// return err
// }
//
// # Testing with Adapters
//
// ## Mock Adapters
//
// // Mock adapter for testing
// type MockAdapter struct {
// tools map[string]tools.Tool
// }
//
// func (m *MockAdapter) GetTools() []tools.Tool {
// var tools []tools.Tool
// for _, tool := range m.tools {
// tools = append(tools, tool)
// }
// return tools
// }
//
// func (m *MockAdapter) AddTool(name string, tool tools.Tool) {
// m.tools[name] = tool
// }
//
// // Use in tests
// func TestAgentWithMockAdapter(t *testing.T) {
// mockAdapter := &MockAdapter{
// tools: make(map[string]tools.Tool),
// }
// mockAdapter.AddTool("test", &MockTool{})
//
// agent, _ := prebuilt.CreateReactAgent(mockLLM, mockAdapter.GetTools(), 10)
// // Test agent behavior
// }
//
// # Extending the Package
//
// To add a new adapter:
//
// 1. Create a new directory under adapter/
//
// 2. Implement the adapter interface
//
// 3. Provide configuration options
//
// 4. Add comprehensive tests
//
// 5. Document with examples
//
// // Example adapter structure
// package myadapter
//
// type MyAdapter struct {
// config Config
// client *MyClient
// }
//
// func (a *MyAdapter) Convert() ([]tools.Tool, error) {
// // Convert external tools to LangChain tools
// }
//
// func (a *MyAdapter) Close() error {
// // Cleanup resources
// }
//
// # Best Practices
//
// 1. **Choose the right adapter for your use case**
// - GoSkills for custom Go implementations
// - MCP for standardized protocols
// - Multiple adapters for diverse toolsets
//
// 2. **Handle adapter failures gracefully**
// - Provide fallback mechanisms
// - Log errors appropriately
// - Continue with available tools
//
// 3. **Optimize performance**
// - Cache converted tools
// - Use connection pooling
// - Lazy load when possible
//
// 4. **Maintain security**
// - Validate external inputs
// - Use secure connections
// - Implement proper authentication
//
// 5. **Test thoroughly**
// - Mock external dependencies
// - Test error scenarios
// - Verify integration correctness
//
// # Community Contributions
//
// The adapter package welcomes contributions for new integrations:
// - gRPC adapter
// - GraphQL adapter
// - REST API generator adapter
// - Database adapter
// - Message queue adapter
//
// Please follow established patterns and provide:
// - Comprehensive tests
// - Clear documentation
// - Error handling
// - Performance considerations
package adapter
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/goskills/goskills.go | adapter/goskills/goskills.go | package goskills
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"github.com/smallnest/goskills"
"github.com/smallnest/goskills/tool"
"github.com/tmc/langchaingo/tools"
)
// SkillTool implements tools.Tool for goskills.
type SkillTool struct {
name string
description string
scriptMap map[string]string
skillPath string
}
var _ tools.Tool = &SkillTool{}
func (t *SkillTool) Name() string {
return t.name
}
func (t *SkillTool) Description() string {
return t.description
}
func (t *SkillTool) MarshalJSON() ([]byte, error) {
return json.Marshal(map[string]any{
"name": t.name,
"description": t.description,
"skillPath": t.skillPath,
"scriptMap": t.scriptMap,
})
}
func (t *SkillTool) Call(ctx context.Context, input string) (string, error) {
// input is the JSON string of arguments
// We need to parse it based on the tool name, similar to goskills runner.go
switch t.name {
case "run_shell_code":
var params struct {
Code string `json:"code"`
Args map[string]any `json:"args"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal run_shell_code arguments: %w", err)
}
shellTool := tool.ShellTool{}
return shellTool.Run(params.Args, params.Code)
case "run_shell_script":
var params struct {
ScriptPath string `json:"scriptPath"`
Args []string `json:"args"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal run_shell_script arguments: %w", err)
}
return tool.RunShellScript(params.ScriptPath, params.Args)
case "run_python_code":
var params struct {
Code string `json:"code"`
Args map[string]any `json:"args"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal run_python_code arguments: %w", err)
}
pythonTool := tool.PythonTool{}
return pythonTool.Run(params.Args, params.Code)
case "run_python_script":
var params struct {
ScriptPath string `json:"scriptPath"`
Args []string `json:"args"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal run_python_script arguments: %w", err)
}
return tool.RunPythonScript(params.ScriptPath, params.Args)
case "read_file":
var params struct {
FilePath string `json:"filePath"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal read_file arguments: %w", err)
}
path := params.FilePath
if !filepath.IsAbs(path) && t.skillPath != "" {
resolvedPath := filepath.Join(t.skillPath, path)
if _, err := os.Stat(resolvedPath); err == nil {
path = resolvedPath
}
}
return tool.ReadFile(path)
case "write_file":
var params struct {
FilePath string `json:"filePath"`
Content string `json:"content"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal write_file arguments: %w", err)
}
err := tool.WriteFile(params.FilePath, params.Content)
if err == nil {
return fmt.Sprintf("Successfully wrote to file: %s", params.FilePath), nil
}
return "", err
case "wikipedia_search":
var params struct {
Query string `json:"query"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal wikipedia_search arguments: %w", err)
}
return tool.WikipediaSearch(params.Query)
case "tavily_search":
var params struct {
Query string `json:"query"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal tavily_search arguments: %w", err)
}
return tool.TavilySearch(params.Query)
case "web_fetch":
var params struct {
URL string `json:"url"`
}
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal web_fetch arguments: %w", err)
}
return tool.WebFetch(params.URL)
default:
if scriptPath, ok := t.scriptMap[t.name]; ok {
var params struct {
Args []string `json:"args"`
}
if input != "" {
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("failed to unmarshal script arguments: %w", err)
}
}
if strings.HasSuffix(scriptPath, ".py") {
return tool.RunPythonScript(scriptPath, params.Args)
} else {
return tool.RunShellScript(scriptPath, params.Args)
}
}
return "", fmt.Errorf("unknown tool: %s", t.name)
}
}
// SkillsToTools converts a goskills.SkillPackage to a slice of tools.Tool.
func SkillsToTools(skill *goskills.SkillPackage) ([]tools.Tool, error) {
availableTools, scriptMap := goskills.GenerateToolDefinitions(skill)
var result []tools.Tool
for _, t := range availableTools {
if t.Function.Name == "" {
continue
}
// Create a description that includes the arguments schema if possible,
// but langchaingo tools usually just have a text description.
// We can append the JSON schema of parameters to the description to help the LLM.
desc := t.Function.Description
// Note: Parameters schema is available via t.Function.Parameters if needed,
// but langchaingo's tools.Tool interface doesn't have a Schema method.
// The schema would need to be handled separately if function calling support is required.
_ = t.Function.Parameters // Acknowledge parameters exist but aren't used here
result = append(result, &SkillTool{
name: t.Function.Name,
description: desc,
scriptMap: scriptMap,
skillPath: skill.Path,
})
}
return result, nil
}
// MCPToTools converts MCP tools to langchaingo tools.
// Note: goskills also supports MCP. We can add a helper for that too if needed,
// but the user specifically asked for "Skills封装".
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/goskills/doc.go | adapter/goskills/doc.go | // Package goskills provides an adapter for integrating GoSkills with LangGraph Go agents.
//
// GoSkills is a framework for defining and executing skills in Go. This adapter allows
// GoSkills-defined skills to be used as tools within LangGraph agents, enabling agents
// to execute Go code, shell commands, and custom operations safely.
//
// # Core Components
//
// ## SkillTool
// The main adapter that wraps GoSkills operations as LangChain-compatible tools:
//
// import (
// "github.com/smallnest/langgraphgo/adapter/goskills"
// "github.com/smallnest/langgraphgo/prebuilt"
// )
//
// // Load skills from a directory
// skills, err := goskills.LoadSkillsFromDir("/path/to/skills")
// if err != nil {
// return err
// }
//
// // Convert skills to LangChain tools
// tools, err := goskills.ConvertToLangChainTools(skills)
// if err != nil {
// return err
// }
//
// // Use with ReAct agent
// agent, err := prebuilt.CreateReactAgent(llm, tools, 10)
//
// # Available Skills
//
// The adapter provides built-in skills for common operations:
//
// ## Shell Code Execution
// Execute shell code with arguments:
//
// tool := &goskills.SkillTool{
// name: "run_shell_code",
// }
//
// result, err := tool.Call(ctx, `{
// "code": "echo $1 $2",
// "args": {"Hello": "World"}
// }`)
//
// ## Shell Script Execution
// Execute existing shell scripts:
//
// tool := &goskills.SkillTool{
// name: "run_shell_script",
// }
//
// result, err := tool.Call(ctx, `{
// "scriptPath": "/path/to/script.sh",
// "args": ["arg1", "arg2"]
// }`)
//
// ## Python Code Execution
// Execute Python code with imports:
//
// tool := &goskills.SkillTool{
// name: "run_python_code",
// }
//
// result, err := tool.Call(ctx, `{
// "code": "import math; print(math.sqrt(16))",
// "imports": ["math", "numpy"],
// "globals": {"value": 42}
// }`)
//
// ## Python Script Execution
// Execute Python scripts:
//
// tool := &goskills.SkillTool{
// name: "run_python_script",
// }
//
// result, err := tool.Call(ctx, `{
// "scriptPath": "/path/to/script.py",
// "args": ["--input", "data.txt"]
// }`)
//
// ## Web Search
// Perform web searches:
//
// tool := &goskills.SkillTool{
// name: "web_search",
// }
//
// result, err := tool.Call(ctx, `{
// "query": "latest AI developments",
// "num_results": 5
// }`)
//
// ## File Operations
// Read and write files:
//
// tool := &goskills.SkillTool{
// name: "file_operations",
// }
//
// // Read file
// result, err := tool.Call(ctx, `{
// "action": "read",
// "path": "/path/to/file.txt"
// }`)
//
// // Write file
// result, err := tool.Call(ctx, `{
// "action": "write",
// "path": "/path/to/output.txt",
// "content": "Hello, World!"
// }`)
//
// # Custom Skills
//
// Define custom Go skills for specific tasks:
//
// // custom_skill.go
// package main
//
// import (
// "fmt"
// "github.com/smallnest/goskills/skill"
// )
//
// type MySkill struct{}
//
// func (s *MySkill) Execute(ctx skill.Context) (any, error) {
// // Extract parameters
// input := ctx.Params["input"].(string)
//
// // Custom logic
// result := fmt.Sprintf("Processed: %s", strings.ToUpper(input))
//
// return result, nil
// }
//
// func NewMySkill() *MySkill {
// return &MySkill{}
// }
//
// Register the skill:
//
// skills := []goskills.Skill{
// goskills.NewSkill("my_custom_skill", "Custom processing skill", NewMySkill),
// }
//
// # Integration Examples
//
// ## With ReAct Agent
//
// // Load skills
// skills, _ := goskills.LoadSkillsFromDir("./skills")
//
// // Convert to tools
// langchainTools, _ := goskills.ConvertToLangChainTools(skills)
//
// // Create agent
// agent, _ := prebuilt.CreateReactAgent(llm, langchainTools, 15)
//
// // Execute
// result, _ := agent.Invoke(ctx, map[string]any{
// "messages": []llms.MessageContent{
// {
// Role: llms.ChatMessageTypeHuman,
// Parts: []llms.ContentPart{
// llms.TextPart("Analyze the data in data.csv and create a plot"),
// },
// },
// },
// })
//
// ## With PTC Agent
//
// ptcTools, _ := goskills.ConvertToLangChainTools(skills)
//
// ptcAgent, _ := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
// Model: llm,
// Tools: ptcTools,
// Language: ptc.LanguagePython,
// })
//
// # Skill Configuration
//
// Skills can be configured with parameters:
//
// type SkillConfig struct {
// Name string `json:"name"`
// Description string `json:"description"`
// Parameters map[string]any `json:"parameters"`
// Timeout time.Duration `json:"timeout"`
// Retry int `json:"retry"`
// Env map[string]string `json:"env"`
// }
//
// // Create configured skill
// skill := goskills.NewSkillWithConfig(SkillConfig{
// Name: "data_processor",
// Description: "Process large datasets",
// Parameters: map[string]any{
// "batch_size": 1000,
// "format": "json",
// },
// Timeout: 30 * time.Second,
// Env: map[string]string{
// "DATA_PATH": "/data",
// },
// })
//
// # Error Handling
//
// The adapter provides structured error handling:
//
// type SkillError struct {
// Code string `json:"code"`
// Message string `json:"message"`
// Skill string `json:"skill"`
// Timestamp string `json:"timestamp"`
// }
//
// result, err := tool.Call(ctx, input)
// if err != nil {
// var skillErr *SkillError
// if errors.As(err, &skillErr) {
// fmt.Printf("Skill %s failed: %s\n", skillErr.Skill, skillErr.Message)
// }
// }
//
// # Security Features
//
// - Sandboxed execution environments
// - Resource limits (CPU, memory, time)
// - Input validation and sanitization
// - Restricted file system access
// - Network access controls
// - Audit logging
//
// # Performance Optimization
//
// - Skill caching for reuse
// - Parallel execution support
// - Connection pooling for external services
// - Result streaming for large outputs
// - Memory management for long-running operations
//
// # Best Practices
//
// 1. Organize skills by functionality
// 2. Provide clear descriptions and examples
// 3. Implement proper error handling
// 4. Use timeouts for long operations
// 5. Validate all inputs
// 6. Log skill executions for debugging
// 7. Test skills with various inputs
// 8. Document skill parameters and return values
//
// # Advanced Features
//
// ## Skill Composition
// Combine multiple skills for complex operations:
//
// type CompositeSkill struct {
// skills []goskills.Skill
// }
//
// func (s *CompositeSkill) Execute(ctx skill.Context) (any, error) {
// // Execute skills in sequence
// for _, sk := range s.skills {
// result, err := sk.Execute(ctx)
// if err != nil {
// return nil, err
// }
// ctx.Params["previous_result"] = result
// }
// return ctx.Params["previous_result"], nil
// }
//
// ## Dynamic Skill Loading
// Load skills from multiple sources:
//
// // From directory
// dirSkills, _ := goskills.LoadSkillsFromDir("./skills")
//
// // From remote repository
// remoteSkills, _ := goskills.LoadSkillsFromRepo("github.com/user/skills")
//
// // From configuration
// configSkills, _ := goskills.LoadSkillsFromConfig("./skills.yaml")
//
// // Combine all skills
// allSkills := append(dirSkills, remoteSkills...)
// allSkills = append(allSkills, configSkills...)
//
// # Monitoring and Debugging
//
// Skills include built-in monitoring:
//
// // Enable metrics collection
// goskills.EnableMetrics()
//
// // Get skill statistics
// stats := goskills.GetSkillStats()
// fmt.Printf("Total executions: %d\n", stats.Total)
// fmt.Printf("Success rate: %.2f%%\n", stats.SuccessRate)
//
// // Trace skill execution
// trace := goskills.TraceSkill("my_skill")
// defer trace.Finish()
//
// # Integration with External Services
//
// Skills can integrate with external APIs:
//
// type APISkill struct {
// client *http.Client
// apiKey string
// baseURL string
// }
//
// func (s *APISkill) Execute(ctx skill.Context) (any, error) {
// // Make API call
// req, _ := http.NewRequest(
// "GET",
// s.baseURL + "/endpoint",
// nil,
// )
// req.Header.Set("Authorization", "Bearer "+s.apiKey)
//
// resp, err := s.client.Do(req)
// if err != nil {
// return nil, err
// }
// defer resp.Body.Close()
//
// // Process response
// var result map[string]any
// json.NewDecoder(resp.Body).Decode(&result)
//
// return result, nil
// }
package goskills
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/goskills/goskills_test.go | adapter/goskills/goskills_test.go | package goskills
import (
"context"
"encoding/json"
"os"
"path/filepath"
"testing"
"github.com/smallnest/goskills"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tmc/langchaingo/tools"
)
// MockSkillPackage 模拟 goskills.SkillPackage 接口
type MockSkillPackage struct {
path string
}
func (m MockSkillPackage) GetName() string {
return "test-skill"
}
func (m MockSkillPackage) GetDescription() string {
return "Test skill package"
}
func (m MockSkillPackage) GetVersion() string {
return "1.0.0"
}
func (m MockSkillPackage) GetPath() string {
return m.path
}
// TestSkillTool_Name tests the Name method
func TestSkillTool_Name(t *testing.T) {
tool := &SkillTool{
name: "test_tool",
}
assert.Equal(t, "test_tool", tool.Name())
}
// TestSkillTool_Description tests the Description method
func TestSkillTool_Description(t *testing.T) {
tool := &SkillTool{
description: "Test tool description",
}
assert.Equal(t, "Test tool description", tool.Description())
}
// TestSkillTool_Call_RunShellCode tests the run_shell_code case
func TestSkillTool_Call_RunShellCode(t *testing.T) {
// Skip if bash is not available
if _, err := os.Stat("/bin/bash"); os.IsNotExist(err) {
t.Skip("Bash not available, skipping test")
}
tool := &SkillTool{
name: "run_shell_code",
}
// Test valid input
params := map[string]any{
"code": "echo 'Hello from shell'",
"args": map[string]any{},
}
input, err := json.Marshal(params)
require.NoError(t, err)
result, err := tool.Call(context.Background(), string(input))
assert.NoError(t, err)
assert.Contains(t, result, "Hello from shell")
}
// TestSkillTool_Call_RunShellCode_InvalidInput tests run_shell_code with invalid input
func TestSkillTool_Call_RunShellCode_InvalidInput(t *testing.T) {
tool := &SkillTool{
name: "run_shell_code",
}
// Test invalid JSON
_, err := tool.Call(context.Background(), "invalid json")
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to unmarshal")
}
// TestSkillTool_Call_RunPythonCode tests the run_python_code case
func TestSkillTool_Call_RunPythonCode(t *testing.T) {
// Skip if python is not available
if _, err := os.Stat("/usr/bin/python3"); os.IsNotExist(err) {
if _, err := os.Stat("/usr/bin/python"); os.IsNotExist(err) {
t.Skip("Python not available, skipping test")
}
}
tool := &SkillTool{
name: "run_python_code",
}
// Test valid input
params := map[string]any{
"code": "print('Hello from Python')",
"args": map[string]any{},
}
input, err := json.Marshal(params)
require.NoError(t, err)
result, err := tool.Call(context.Background(), string(input))
assert.NoError(t, err)
assert.Contains(t, result, "Hello from Python")
}
// TestSkillTool_Call_ReadFile tests the read_file case
func TestSkillTool_Call_ReadFile(t *testing.T) {
tmpDir := t.TempDir()
testFile := filepath.Join(tmpDir, "test.txt")
testContent := "Test file content"
err := os.WriteFile(testFile, []byte(testContent), 0644)
require.NoError(t, err)
tool := &SkillTool{
name: "read_file",
}
// Test with absolute path
params := map[string]string{
"filePath": testFile,
}
input, err := json.Marshal(params)
require.NoError(t, err)
result, err := tool.Call(context.Background(), string(input))
assert.NoError(t, err)
assert.Equal(t, testContent, result)
// Test with relative path and skillPath
tool.skillPath = tmpDir
params = map[string]string{
"filePath": "test.txt",
}
input, err = json.Marshal(params)
require.NoError(t, err)
result, err = tool.Call(context.Background(), string(input))
assert.NoError(t, err)
assert.Equal(t, testContent, result)
}
// TestSkillTool_Call_WriteFile tests the write_file case
func TestSkillTool_Call_WriteFile(t *testing.T) {
tmpDir := t.TempDir()
testFile := filepath.Join(tmpDir, "write_test.txt")
testContent := "Content to write"
tool := &SkillTool{
name: "write_file",
}
params := map[string]string{
"filePath": testFile,
"content": testContent,
}
input, err := json.Marshal(params)
require.NoError(t, err)
result, err := tool.Call(context.Background(), string(input))
assert.NoError(t, err)
assert.Contains(t, result, "Successfully wrote to file")
// Verify file was written
content, err := os.ReadFile(testFile)
assert.NoError(t, err)
assert.Equal(t, testContent, string(content))
}
// TestSkillTool_Call_UnknownTool tests unknown tool case
func TestSkillTool_Call_UnknownTool(t *testing.T) {
tool := &SkillTool{
name: "unknown_tool",
}
result, err := tool.Call(context.Background(), "{}")
assert.Error(t, err)
assert.Empty(t, result)
assert.Contains(t, err.Error(), "unknown tool")
}
// TestSkillTool_Call_CustomScript tests custom script execution
func TestSkillTool_Call_CustomScript(t *testing.T) {
// Skip if bash is not available
if _, err := os.Stat("/bin/bash"); os.IsNotExist(err) {
t.Skip("Bash not available, skipping test")
}
tmpDir := t.TempDir()
scriptPath := filepath.Join(tmpDir, "test.sh")
scriptContent := "#!/bin/bash\necho 'Custom script executed'"
err := os.WriteFile(scriptPath, []byte(scriptContent), 0755)
require.NoError(t, err)
tool := &SkillTool{
name: "custom_script",
scriptMap: map[string]string{
"custom_script": scriptPath,
},
}
result, err := tool.Call(context.Background(), `{"args": []}`)
assert.NoError(t, err)
assert.Contains(t, result, "Custom script executed")
}
// TestSkillsToTools tests the SkillsToTools function
func TestSkillsToTools(t *testing.T) {
// Since we can't easily create a real goskills.SkillPackage without the dependency,
// we'll just verify the function exists and can be called with proper types.
// In a real scenario with the goskills dependency, you would create a mock skill package.
t.Run("function_signature", func(t *testing.T) {
// Verify the function exists by checking its type
var _ func(*goskills.SkillPackage) ([]tools.Tool, error) = SkillsToTools
// This will compile if the function exists with the correct signature
})
}
// TestSkillTool_ImplementsInterface verifies SkillTool implements tools.Tool
func TestSkillTool_ImplementsInterface(t *testing.T) {
var _ tools.Tool = &SkillTool{}
tool := &SkillTool{
name: "test",
description: "test description",
}
assert.Equal(t, "test", tool.Name())
assert.Equal(t, "test description", tool.Description())
}
// TestSkillTool_Call_EdgeCases tests various edge cases
func TestSkillTool_Call_EdgeCases(t *testing.T) {
tests := []struct {
name string
toolName string
input string
expectError bool
}{
{
name: "empty input for run_shell_code",
toolName: "run_shell_code",
input: "",
expectError: true,
},
{
name: "missing code parameter",
toolName: "run_shell_code",
input: `{"args": {}}`,
expectError: false, // The tool might handle empty code gracefully
},
{
name: "invalid file path for read_file",
toolName: "read_file",
input: `{"filePath": ""}`,
expectError: true,
},
{
name: "empty query for duckduckgo_search",
toolName: "duckduckgo_search",
input: `{"query": ""}`,
expectError: false, // Might not error, just return empty result
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tool := &SkillTool{
name: tt.toolName,
}
_, err := tool.Call(context.Background(), tt.input)
if tt.expectError {
assert.Error(t, err)
} else {
// Don't assert on success as some cases might fail due to external dependencies
_ = err
}
})
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/mcp/doc.go | adapter/mcp/doc.go | // Package mcp provides an adapter for integrating Model Context Protocol (MCP) tools with LangGraph Go agents.
//
// MCP is an open protocol that allows AI assistants to securely connect to external data sources
// and tools. This adapter enables LangGraph agents to use MCP-compliant tools and services,
// providing access to a growing ecosystem of MCP integrations including databases, APIs,
// file systems, and more.
//
// # Core Components
//
// ## MCPTool
// The main adapter that wraps MCP protocol tools as LangChain-compatible tools:
//
// import (
// "github.com/smallnest/langgraphgo/adapter/mcp"
// "github.com/smallnest/langgraphgo/prebuilt"
// )
//
// // Connect to MCP server
// client, err := mcp.NewMCPClient("stdio", []string{"python", "mcp_server.py"})
// if err != nil {
// return err
// }
// defer client.Close()
//
// // List available tools
// tools, err := client.ListTools()
// if err != nil {
// return err
// }
//
// // Convert MCP tools to LangChain tools
// langchainTools := make([]tools.Tool, len(tools))
// for i, mcpTool := range tools {
// langchainTools[i] = &mcp.MCPTool{
// name: mcpTool.Name,
// description: mcpTool.Description,
// client: client,
// parameters: mcpTool.InputSchema,
// }
// }
//
// // Use with ReAct agent
// agent, err := prebuilt.CreateReactAgent(llm, langchainTools, 10)
//
// # MCP Server Integration
//
// ## Standard Input/Output (stdio)
// Most common connection type for local MCP servers:
//
// client, err := mcp.NewMCPClient("stdio", []string{
// "python",
// "-m",
// "mcp_server_sqlite",
// "--db-path",
// "/path/to/database.db",
// })
//
// ## HTTP Transport
// Connect to remote MCP servers via HTTP:
//
// client, err := mcp.NewMCPClientWithConfig(mcp.Config{
// Transport: "http",
// URL: "http://localhost:8080/mcp",
// Headers: map[string]string{
// "Authorization": "Bearer your-token",
// },
// })
//
// ## WebSocket Transport
// Real-time bidirectional communication:
//
// client, err := mcp.NewMCPClientWithConfig(mcp.Config{
// Transport: "websocket",
// URL: "ws://localhost:8080/ws",
// })
//
// # Available MCP Tools
//
// ## Database Tools
// Query databases through MCP:
//
// // SQLite MCP server
// client, _ := mcp.NewMCPClient("stdio", []string{
// "sqlite-mcp",
// "--db-path", "./data.db",
// })
//
// // Use database tools
// agent, _ := prebuilt.CreateReactAgent(llm, mcpTools, 10)
//
// result, _ := agent.Invoke(ctx, map[string]any{
// "messages": []llms.MessageContent{
// {
// Role: llms.ChatMessageTypeHuman,
// Parts: []llms.ContentPart{
// llms.TextPart("Show me all users from the database"),
// },
// },
// },
// })
//
// ## File System Tools
// Access file systems through MCP:
//
// // File system MCP server
// client, _ := mcp.NewMCPClient("stdio", []string{
// "filesystem-mcp",
// "--root", "/allowed/path",
// })
//
// // Agent can now read/write files
// result, _ := agent.Invoke(ctx, map[string]any{
// "messages": []llms.MessageContent{
// {
// Role: llms.ChatMessageTypeHuman,
// Parts: []llms.ContentPart{
// llms.TextPart("Read the config.yaml file and update the port to 8080"),
// },
// },
// },
// })
//
// ## Web API Tools
// Connect to web services through MCP:
//
// // GitHub MCP server
// client, _ := mcp.NewMCPClient("stdio", []string{
// "github-mcp",
// "--token", os.Getenv("GITHUB_TOKEN"),
// })
//
// // Agent can interact with GitHub
// result, _ := agent.Invoke(ctx, map[string]any{
// "messages": []llms.MessageContent{
// {
// Role: llms.ChatMessageTypeHuman,
// Parts: []llms.ContentPart{
// llms.TextPart("List all pull requests in the langgraph-go repository"),
// },
// },
// },
// })
//
// # Integration Examples
//
// ## Multi-Tool Agent with Multiple MCP Servers
//
// // Connect to multiple MCP servers
// sqliteClient, _ := mcp.NewMCPClient("stdio", []string{
// "sqlite-mcp",
// "--db-path", "./data.db",
// })
// defer sqliteClient.Close()
//
// fsClient, _ := mcp.NewMCPClient("stdio", []string{
// "filesystem-mcp",
// "--root", "/data",
// })
// defer fsClient.Close()
//
// // Collect all tools
// var allTools []tools.Tool
//
// sqliteTools, _ := sqliteClient.ListTools()
// for _, t := range sqliteTools {
// allTools = append(allTools, &mcp.MCPTool{
// name: t.Name,
// description: t.Description,
// client: sqliteClient,
// parameters: t.InputSchema,
// })
// }
//
// fsTools, _ := fsClient.ListTools()
// for _, t := range fsTools {
// allTools = append(allTools, &mcp.MCPTool{
// name: t.Name,
// description: t.Description,
// client: fsClient,
// parameters: t.InputSchema,
// })
// }
//
// // Create agent with all MCP tools
// agent, _ := prebuilt.CreateReactAgent(llm, allTools, 20)
//
// ## Dynamic Tool Discovery
//
// // Discover tools at runtime
// client, _ := mcp.NewMCPClient("stdio", []string{"dynamic-mcp-server"})
//
// // Periodically refresh tool list
// ticker := time.NewTicker(5 * time.Minute)
// go func() {
// for range ticker.C {
// tools, _ := client.ListTools()
// // Update agent's tool list
// updateAgentTools(agent, tools)
// }
// }()
//
// # MCP Configuration
//
// ## Client Configuration
//
// config := mcp.Config{
// Transport: "stdio",
// Command: []string{"python", "server.py"},
// Env: map[string]string{
// "API_KEY": "your-api-key",
// "DEBUG": "true",
// },
// Timeout: 30 * time.Second,
// MaxRetries: 3,
// Headers: map[string]string{
// "User-Agent": "LangGraph-Go/1.0",
// },
// }
//
// client, _ := mcp.NewMCPClientWithConfig(config)
//
// ## Tool Configuration
//
// // Configure individual tools
// mcpTool := &mcp.MCPTool{
// name: "database_query",
// description: "Execute SQL queries",
// client: client,
// parameters: map[string]any{
// "type": "object",
// "properties": map[string]any{
// "query": map[string]any{
// "type": "string",
// "description": "SQL query to execute",
// },
// },
// "required": []string{"query"},
// },
// }
//
// # Error Handling
//
// The adapter provides comprehensive error handling:
//
// result, err := mcpTool.Call(ctx, input)
// if err != nil {
// var mcpErr *mcp.MCPError
// if errors.As(err, &mcpErr) {
// fmt.Printf("MCP Error: %s (Code: %d)\n", mcpErr.Message, mcpErr.Code)
// fmt.Printf("Tool: %s\n", mcpErr.Tool)
// fmt.Printf("Data: %v\n", mcpErr.Data)
// }
// }
//
// # Security Features
//
// - Authentication and authorization
// - Request/response validation
// - Rate limiting
// - Audit logging
// - Secure transport layers
// - Permission scopes
//
// # Performance Optimization
//
// - Connection pooling
// - Request batching
// - Response caching
// - Compression
// - Keep-alive connections
//
// # Best Practices
//
// 1. Use appropriate transport for your use case (stdio for local, HTTP for remote)
// 2. Set reasonable timeouts for tool execution
// 3. Handle MCP errors gracefully
// 4. Close clients when done
// 5. Validate tool parameters before calling
// 6. Use environment variables for sensitive configuration
// 7. Monitor tool usage and performance
// 8. Implement retry logic for transient errors
//
// # Advanced Features
//
// ## Tool Streaming
// For long-running operations:
//
// client, _ := mcp.NewMCPClient("stdio", cmd)
//
// // Enable streaming for specific tools
// mcpTool := &mcp.MCPTool{
// name: "long_running_task",
// description: "Execute long-running task with streaming",
// client: client,
// streaming: true,
// }
//
// // Handle streaming response
// ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
// defer cancel()
//
// result, err := mcpTool.CallWithStream(ctx, input, func(chunk string) {
// fmt.Printf("Progress: %s\n", chunk)
// })
//
// ## Tool Composition
// Combine multiple MCP tools:
//
// // Create a composite tool that uses multiple MCP tools
// type CompositeMCPTool struct {
// tools []*mcp.MCPTool
// }
//
// func (t *CompositeMCPTool) Name() string {
// return "composite_operation"
// }
//
// func (t *CompositeMCPTool) Description() string {
// return "Performs complex operation using multiple tools"
// }
//
// func (t *CompositeMCPTool) Call(ctx context.Context, input string) (string, error) {
// // Parse input to determine sequence of operations
// var ops []Operation
// json.Unmarshal([]byte(input), &ops)
//
// // Execute tools in sequence
// var results []any
// for _, op := range ops {
// for _, tool := range t.tools {
// if tool.Name() == op.Tool {
// result, _ := tool.Call(ctx, op.Params)
// results = append(results, result)
// }
// }
// }
//
// // Return combined results
// return json.Marshal(results)
// }
//
// # MCP Server Development
//
// Create custom MCP servers:
//
// // server.py
// import asyncio
// from mcp.server import Server
// from mcp.server.stdio import stdio_server
// from mcp.types import Tool
//
// app = Server("my-mcp-server")
//
// @app.list_tools()
// async def list_tools() -> list[Tool]:
// return [
// Tool(
// name="my_tool",
// description="Custom tool description",
// inputSchema={
// "type": "object",
// "properties": {
// "param1": {"type": "string"},
// },
// "required": ["param1"],
// },
// ),
// ]
//
// @app.call_tool()
// async def call_tool(name: str, arguments: dict) -> str:
// if name == "my_tool":
// # Custom tool logic
// return f"Processed: {arguments['param1']}"
//
// async def main():
// async with stdio_server() as (read_stream, write_stream):
// await app.run(read_stream, write_stream)
//
// if __name__ == "__main__":
// asyncio.run(main())
//
// # Monitoring and Debugging
//
// // Enable MCP logging
// client, _ := mcp.NewMCPClientWithConfig(mcp.Config{
// Transport: "stdio",
// Command: []string{"python", "server.py"},
// LogLevel: "debug",
// LogFile: "/tmp/mcp.log",
// })
//
// // Get client statistics
// stats := client.GetStats()
// fmt.Printf("Total requests: %d\n", stats.Requests)
// fmt.Printf("Average latency: %v\n", stats.AvgLatency)
// fmt.Printf("Error rate: %.2f%%\n", stats.ErrorRate)
//
// # Community MCP Servers
//
// Popular MCP servers to integrate:
//
// - sqlite-mcp: Database access
// - filesystem-mcp: File system operations
// - github-mcp: GitHub API integration
// - slack-mcp: Slack workspace access
// - gmail-mcp: Email management
// - postgres-mcp: PostgreSQL database
// - redis-mcp: Redis operations
// - kubernetes-mcp: Kubernetes cluster management
// - aws-mcp: AWS service integration
// - mongodb-mcp: MongoDB database access
package mcp
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/mcp/mcp.go | adapter/mcp/mcp.go | package mcp
import (
"context"
"encoding/json"
"fmt"
"github.com/sashabaranov/go-openai"
mcpclient "github.com/smallnest/goskills/mcp"
"github.com/tmc/langchaingo/tools"
)
// MCPTool implements tools.Tool for MCP (Model Context Protocol) tools.
type MCPTool struct {
name string
description string
client *mcpclient.Client
parameters any // JSON schema for the tool parameters
}
var _ tools.Tool = &MCPTool{}
func (t *MCPTool) Name() string {
return t.name
}
func (t *MCPTool) Description() string {
return t.description
}
func (t *MCPTool) Call(ctx context.Context, input string) (string, error) {
// Parse input JSON into a map
var args map[string]any
if input != "" {
if err := json.Unmarshal([]byte(input), &args); err != nil {
// 如果 JSON 解析失败，尝试作为纯文本参数传递
// 有些 MCP 工具可能接受简单的字符串参数
args = map[string]any{"input": input}
}
} else {
// 空输入时使用空对象
args = make(map[string]any)
}
// Call the MCP tool through the client
result, err := t.client.CallTool(ctx, t.name, args)
if err != nil {
return "", fmt.Errorf("failed to call MCP tool %s: %w", t.name, err)
}
// Convert result to JSON string
resultJSON, err := json.Marshal(result)
if err != nil {
return "", fmt.Errorf("failed to marshal MCP tool result: %w", err)
}
return string(resultJSON), nil
}
// MCPToTools converts MCP tools from a client to langchaingo tools.
// It fetches all available tools from the connected MCP servers and wraps them
// as langchaingo tools.Tool instances.
func MCPToTools(ctx context.Context, client *mcpclient.Client) ([]tools.Tool, error) {
// Get all OpenAI tools from MCP servers
openaiTools, err := client.GetTools(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get MCP tools: %w", err)
}
// Convert to langchaingo tools
var result []tools.Tool
for _, t := range openaiTools {
if t.Function == nil || t.Function.Name == "" {
continue
}
result = append(result, &MCPTool{
name: t.Function.Name,
description: t.Function.Description,
client: client,
parameters: t.Function.Parameters,
})
}
return result, nil
}
// NewClientFromConfig creates a new MCP client from a config file path.
// This is a convenience function that loads the config and creates a client.
func NewClientFromConfig(ctx context.Context, configPath string) (*mcpclient.Client, error) {
config, err := mcpclient.LoadConfig(configPath)
if err != nil {
return nil, fmt.Errorf("failed to load MCP config: %w", err)
}
client, err := mcpclient.NewClient(ctx, config)
if err != nil {
return nil, fmt.Errorf("failed to create MCP client: %w", err)
}
return client, nil
}
// GetToolSchema returns the JSON schema for a tool's parameters.
// This can be useful for debugging or generating documentation.
func GetToolSchema(tool tools.Tool) (any, bool) {
if mcpTool, ok := tool.(*MCPTool); ok {
return mcpTool.parameters, true
}
return nil, false
}
// MCPToolsToOpenAI converts MCP tools to OpenAI tool definitions.
// This is useful when you need to use MCP tools directly with OpenAI's API.
func MCPToolsToOpenAI(ctx context.Context, client *mcpclient.Client) ([]openai.Tool, error) {
return client.GetTools(ctx)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/adapter/mcp/mcp_test.go | adapter/mcp/mcp_test.go | package mcp
import (
"context"
"os"
"path/filepath"
"testing"
"github.com/sashabaranov/go-openai"
mcpclient "github.com/smallnest/goskills/mcp"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tmc/langchaingo/tools"
)
func TestMCPTool_Interface(t *testing.T) {
// Verify that MCPTool implements tools.Tool interface
var _ tools.Tool = &MCPTool{}
}
func TestMCPTool_NameAndDescription(t *testing.T) {
tool := &MCPTool{
name: "test_tool",
description: "A test tool",
}
assert.Equal(t, "test_tool", tool.Name())
assert.Equal(t, "A test tool", tool.Description())
}
func TestGetToolSchema(t *testing.T) {
schema := map[string]any{
"type": "object",
"properties": map[string]any{
"query": map[string]any{
"type": "string",
"description": "Search query",
},
},
}
tool := &MCPTool{
name: "search",
description: "Search tool",
parameters: schema,
}
retrievedSchema, ok := GetToolSchema(tool)
assert.True(t, ok)
assert.Equal(t, schema, retrievedSchema)
// Test with non-MCP tool (using a different MCPTool without the schema)
nonMCPTool := &MCPTool{
name: "other",
description: "Other tool",
parameters: nil,
}
retrievedSchema, ok = GetToolSchema(nonMCPTool)
assert.True(t, ok)
assert.Nil(t, retrievedSchema)
}
// TestMCPToTools_EmptyClient tests the conversion with no tools
func TestMCPToTools_EmptyConversion(t *testing.T) {
// This test would require a mock MCP client
// For now, we just verify the function signature exists
ctx := context.Background()
// We can't actually call MCPToTools without a real client,
// but we verify the function exists and has the right signature
_ = ctx
// Type check
var fn func(context.Context, any) ([]tools.Tool, error)
_ = fn
}
// Example usage documentation
func ExampleMCPToTools() {
ctx := context.Background()
// Load MCP client from config file
client, err := NewClientFromConfig(ctx, "~/.claude.json")
if err != nil {
panic(err)
}
defer client.Close()
// Convert MCP tools to langchaingo tools
tools, err := MCPToTools(ctx, client)
if err != nil {
panic(err)
}
// Use tools with langchaingo or langgraphgo agents
_ = tools
}
func ExampleNewClientFromConfig() {
ctx := context.Background()
// Create MCP client from Claude config file
client, err := NewClientFromConfig(ctx, "~/.claude.json")
if err != nil {
panic(err)
}
defer client.Close()
// Now you can use the client to get tools or call them directly
_ = client
}
// Note: 由于 mcp.Client 接口的复杂性，我们无法轻易创建 mock
// 我们将专注于测试不依赖外部客户端的部分
// TestMCPTool_Call 测试 MCPTool 的 Call 方法
func TestMCPTool_Call(t *testing.T) {
// 由于接口限制，我们只能测试基本功能
// 在实际场景中，需要真实的 MCP 客户端
t.Run("mock_client_scenario", func(t *testing.T) {
// 验证函数签名和基本结构
tool := &MCPTool{
name: "test_tool",
description: "A test tool",
client: nil, // 在实际测试中这会导致错误
}
assert.Equal(t, "test_tool", tool.Name())
assert.Equal(t, "A test tool", tool.Description())
// 测试 JSON 解析逻辑（在调用 client 之前）
ctx := context.Background()
validInput := `{"message": "Hello, MCP!"}`
// 由于 client 是 nil，这会 panic，但我们可以捕获它
defer func() {
if r := recover(); r != nil {
t.Logf("Expected panic with nil client: %v", r)
}
}()
_, err := tool.Call(ctx, validInput)
// 我们不关心结果，因为会 panic
_ = err
})
}
// TestMCPTool_Call_EmptyInput 测试空输入
func TestMCPTool_Call_EmptyInput(t *testing.T) {
tool := &MCPTool{
name: "test_tool",
client: nil, // 会导致 panic
}
ctx := context.Background()
defer func() {
if r := recover(); r != nil {
t.Logf("Expected panic with nil client: %v", r)
}
}()
_, err := tool.Call(ctx, "")
// 我们不关心结果，因为会 panic
_ = err
}
// TestMCPTool_Call_InvalidJSON 测试无效 JSON 输入
func TestMCPTool_Call_InvalidJSON(t *testing.T) {
tool := &MCPTool{
name: "test_tool",
client: nil, // 会在 JSON 解析后 panic
}
ctx := context.Background()
_, err := tool.Call(ctx, "{invalid json}")
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to call MCP tool")
}
// TestMCPTool_Call_ClientError 测试客户端错误
func TestMCPTool_Call_ClientError(t *testing.T) {
// 由于接口限制，我们无法正确模拟客户端错误
// 但我们可以验证错误处理逻辑
tool := &MCPTool{
name: "error_tool",
client: nil, // 会导致 panic
}
ctx := context.Background()
defer func() {
if r := recover(); r != nil {
t.Logf("Expected panic with nil client: %v", r)
}
}()
_, err := tool.Call(ctx, "{}")
// 我们不关心结果，因为会 panic
_ = err
}
// TestMCPToTools_FunctionSignature 测试 MCPToTools 函数签名
func TestMCPToTools_FunctionSignature(t *testing.T) {
// 验证函数存在并有正确的签名
var _ func(context.Context, *mcpclient.Client) ([]tools.Tool, error) = MCPToTools
}
// TestNewClientFromConfig_NonExistentFile 测试不存在的配置文件
func TestNewClientFromConfig_NonExistentFile(t *testing.T) {
ctx := context.Background()
// 测试不存在的文件路径
_, err := NewClientFromConfig(ctx, "/non/existent/path/config.json")
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to load MCP config")
}
// TestNewClientFromConfig_InvalidConfig 测试无效的配置文件
func TestNewClientFromConfig_InvalidConfig(t *testing.T) {
tmpDir := t.TempDir()
configFile := filepath.Join(tmpDir, "invalid_config.json")
// 写入无效的 JSON
err := os.WriteFile(configFile, []byte("{invalid json"), 0644)
require.NoError(t, err)
ctx := context.Background()
_, err = NewClientFromConfig(ctx, configFile)
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to load MCP config")
}
// TestGetToolSchema_NonMCPTool 测试非 MCP 工具
func TestGetToolSchema_NonMCPTool(t *testing.T) {
// 使用一个简单的工具实现
nonMCPTool := &simpleTool{name: "test"}
schema, ok := GetToolSchema(nonMCPTool)
assert.False(t, ok)
assert.Nil(t, schema)
}
// simpleTool 简单的工具实现用于测试
type simpleTool struct {
name string
}
func (t *simpleTool) Name() string { return t.name }
func (t *simpleTool) Description() string { return "Simple test tool" }
func (t *simpleTool) Call(ctx context.Context, input string) (string, error) {
return "result", nil
}
// TestMCPToolsToOpenAI_FunctionSignature 测试 MCPToolsToOpenAI 函数签名
func TestMCPToolsToOpenAI_FunctionSignature(t *testing.T) {
// 验证函数存在并有正确的签名
var _ func(context.Context, *mcpclient.Client) ([]openai.Tool, error) = MCPToolsToOpenAI
}
// TestMCPTool_EdgeCases 测试边界情况
func TestMCPTool_EdgeCases(t *testing.T) {
tests := []struct {
name string
setupTool func() *MCPTool
input string
expectError bool
}{
{
name: "nil client",
setupTool: func() *MCPTool {
return &MCPTool{
name: "test",
client: nil,
}
},
input: "{}",
expectError: true, // 应该 panic 或返回错误
},
{
name: "empty tool name",
setupTool: func() *MCPTool {
return &MCPTool{
name: "",
client: nil, // 会导致 panic
}
},
input: "{}",
expectError: false, // 空名字可能不会导致错误
},
{
name: "invalid JSON",
setupTool: func() *MCPTool {
return &MCPTool{
name: "test",
client: nil,
}
},
input: `{invalid json}`,
expectError: true,
},
{
name: "valid JSON",
setupTool: func() *MCPTool {
return &MCPTool{
name: "test",
client: nil,
}
},
input: `{
"param1": "value1",
"param2": 123
}`,
expectError: false, // JSON 解析会成功，但之后会 panic
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tool := tt.setupTool()
ctx := context.Background()
defer func() {
if r := recover(); r != nil {
// 对于 nil client 的情况，panic 是可接受的
t.Logf("Recovered from panic: %v", r)
}
}()
_, err := tool.Call(ctx, tt.input)
if tt.expectError {
assert.Error(t, err)
}
})
}
}
// TestMCPTool_ParameterHandling 测试参数处理
func TestMCPTool_ParameterHandling(t *testing.T) {
schema := map[string]any{
"type": "object",
"properties": map[string]any{
"required_param": map[string]any{
"type": "string",
},
"optional_param": map[string]any{
"type": "number",
},
},
"required": []string{"required_param"},
}
tool := &MCPTool{
name: "parameter_test",
description: "Tool for testing parameters",
parameters: schema,
}
// 测试获取 schema
retrievedSchema, ok := GetToolSchema(tool)
assert.True(t, ok)
assert.Equal(t, schema, retrievedSchema)
// 验证 schema 结构
if schemaMap, ok := retrievedSchema.(map[string]any); ok {
assert.Equal(t, "object", schemaMap["type"])
if props, ok := schemaMap["properties"].(map[string]any); ok {
assert.Contains(t, props, "required_param")
assert.Contains(t, props, "optional_param")
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/log/golog_logger.go | log/golog_logger.go | package log
import (
"github.com/kataras/golog"
)
// GologLogger implements Logger interface using kataras/golog
type GologLogger struct {
logger *golog.Logger
level LogLevel
}
var _ Logger = (*GologLogger)(nil)
// NewGologLogger creates a new logger using an existing golog.Logger
func NewGologLogger(logger *golog.Logger) *GologLogger {
return &GologLogger{
logger: logger,
level: LogLevelInfo, // default level
}
}
// Debug logs debug messages
func (l *GologLogger) Debug(format string, v ...any) {
if l.level <= LogLevelDebug {
args := append([]any{format}, v...)
l.logger.Debug(args...)
}
}
// Info logs informational messages
func (l *GologLogger) Info(format string, v ...any) {
if l.level <= LogLevelInfo {
args := append([]any{format}, v...)
l.logger.Info(args...)
}
}
// Warn logs warning messages
func (l *GologLogger) Warn(format string, v ...any) {
if l.level <= LogLevelWarn {
args := append([]any{format}, v...)
l.logger.Warn(args...)
}
}
// Error logs error messages
func (l *GologLogger) Error(format string, v ...any) {
if l.level <= LogLevelError {
args := append([]any{format}, v...)
l.logger.Error(args...)
}
}
// SetLevel sets the log level
func (l *GologLogger) SetLevel(level LogLevel) {
l.level = level
// Convert to golog level string
gologLevel := "info"
switch level {
case LogLevelDebug:
gologLevel = "debug"
case LogLevelInfo:
gologLevel = "info"
case LogLevelWarn:
gologLevel = "warn"
case LogLevelError:
gologLevel = "error"
case LogLevelNone:
gologLevel = "disable"
}
l.logger.SetLevel(gologLevel)
}
// GetLevel returns the current log level
func (l *GologLogger) GetLevel() LogLevel {
return l.level
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/log/golog_logger_test.go | log/golog_logger_test.go | package log
import (
"testing"
"github.com/kataras/golog"
"github.com/stretchr/testify/assert"
)
func TestNewGologLogger(t *testing.T) {
// Create a golog logger
glogger := golog.New()
// Create our GologLogger
logger := NewGologLogger(glogger)
assert.NotNil(t, logger)
assert.Equal(t, LogLevelInfo, logger.GetLevel())
}
func TestGologLogger_LevelControl(t *testing.T) {
glogger := golog.New()
logger := NewGologLogger(glogger)
// Test setting different levels
logger.SetLevel(LogLevelDebug)
assert.Equal(t, LogLevelDebug, logger.GetLevel())
logger.SetLevel(LogLevelError)
assert.Equal(t, LogLevelError, logger.GetLevel())
logger.SetLevel(LogLevelNone)
assert.Equal(t, LogLevelNone, logger.GetLevel())
}
func TestGologLogger_Logging(t *testing.T) {
glogger := golog.New()
logger := NewGologLogger(glogger)
// Set to debug level to ensure all messages are logged
logger.SetLevel(LogLevelDebug)
// Test logging methods - these should not panic
logger.Debug("Debug message")
logger.Info("Info message")
logger.Warn("Warning message")
logger.Error("Error message")
// Test with formatted messages
logger.Debug("Debug: %s", "test")
logger.Info("Info: %d", 42)
logger.Warn("Warn: %v", map[string]string{"key": "value"})
logger.Error("Error: %f", 3.14)
}
func TestGologLogger_LevelFiltering(t *testing.T) {
glogger := golog.New()
logger := NewGologLogger(glogger)
// Set to error level
logger.SetLevel(LogLevelError)
assert.Equal(t, LogLevelError, logger.GetLevel())
// These methods will check level but won't panic
logger.Debug("This should be filtered")
logger.Info("This should be filtered")
logger.Warn("This should be filtered")
logger.Error("This should be logged")
}
func TestGologLogger_Implementation(t *testing.T) {
// Verify GologLogger implements Logger interface
var _ Logger = (*GologLogger)(nil)
glogger := golog.New()
logger := NewGologLogger(glogger)
assert.NotNil(t, logger)
}
func TestGologLogger_CustomGologInstance(t *testing.T) {
// Create a custom golog with specific configuration
glogger := golog.New()
glogger.SetLevel("error")
glogger.SetPrefix("[CUSTOM] ")
logger := NewGologLogger(glogger)
assert.NotNil(t, logger)
// Test that our level control works independently
logger.SetLevel(LogLevelDebug)
assert.Equal(t, LogLevelDebug, logger.GetLevel())
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/log/doc.go | log/doc.go | // Package log provides a simple, leveled logging interface for LangGraph Go applications.
//
// This package implements a lightweight logging system with support for different log levels
// and customizable output destinations. It's designed to integrate seamlessly with the
// LangGraph execution engine, particularly for PTC (Problem-Tactic-Criticality) workflows.
//
// # Log Levels
//
// The package supports five log levels, in order of increasing severity:
//
// - LogLevelDebug: Detailed debugging information for development
// - LogLevelInfo: General informational messages about normal operation
// - LogLevelWarn: Warning messages for potentially problematic situations
// - LogLevelError: Error messages for failures that need attention
// - LogLevelNone: Disables all logging output
//
// # Logger Interface
//
// The Logger interface provides four main logging methods:
//
// - Debug: For detailed troubleshooting information
// - Info: For general application flow information
// - Warn: For issues that don't stop execution but need attention
// - Error: For failures and exceptions
//
// # Example Usage
//
// ## Basic Logging
//
// // Create a logger with INFO level
// logger := log.NewDefaultLogger(log.LogLevelInfo)
//
// // Log messages at different levels
// logger.Info("Application starting")
// logger.Debug("Processing request: %v", request)
// logger.Warn("Rate limit approaching: %d requests", count)
// logger.Error("Failed to process: %v", err)
//
// ## Custom Output
//
// // Create a logger that writes to a file
// file, err := os.OpenFile("app.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
// if err != nil {
// log.Fatal(err)
// }
// defer file.Close()
//
// logger := log.NewCustomLogger(file, log.LogLevelDebug)
// logger.Debug("This will go to the file")
//
// ## Multi-Writer Logging
//
// // Create a logger that writes to both console and file
// multiWriter := io.MultiWriter(os.Stdout, file)
// logger := log.NewCustomWriterLogger(multiWriter, log.LogLevelInfo)
//
// ## Filtering by Level
//
// // Create a debug logger for development
// debugLogger := log.NewDefaultLogger(log.LogLevelDebug)
//
// // Create a production logger that only shows warnings and errors
// prodLogger := log.NewDefaultLogger(log.LogLevelWarn)
//
// // Messages below the set level are filtered out
// debugLogger.Debug("Visible in debug mode")
// prodLogger.Debug("Not visible in production")
//
// # Integration with LangGraph
//
// The logger is designed to work with the graph package's listener system:
//
// import (
// "github.com/smallnest/langgraphgo/graph"
// "github.com/smallnest/langgraphgo/log"
// )
//
// logger := log.NewDefaultLogger(log.LogLevelInfo)
//
// g := graph.NewStateGraph()
// // ... configure graph ...
//
// // Add a logging listener
// listener := graph.NewLoggingListener(logger, log.LogLevelInfo, false)
// g.AddListener(listener)
//
// # Performance Considerations
//
// - Log messages are formatted using fmt.Sprintf() - avoid complex formatting in hot paths
// - Consider setting LogLevelError or LogLevelNone in production for better performance
// - Buffer file writes for high-volume logging scenarios
//
// # Thread Safety
//
// The DefaultLogger implementation is thread-safe and can be used concurrently from
// multiple goroutines. The underlying log.Logger from Go's standard library handles
// synchronization internally.
//
// # Available Implementations
//
// ## Standard Library Logger
//
// The package provides a DefaultLogger implementation using Go's standard log package.
//
// ## golog Integration
//
// For users who prefer the `github.com/kataras/golog` library, we provide a minimal wrapper:
//
// import "github.com/kataras/golog"
//
// // Create a golog logger
// glogger := golog.New()
// glogger.SetPrefix("[MyApp] ")
//
// // Wrap it with LangGraph's Logger interface
// logger := log.NewGologLogger(glogger)
//
// // Use like any other LangGraph logger
// logger.Info("Application started")
// logger.SetLevel(log.LogLevelDebug)
// logger.Debug("Debug information")
//
// Key points:
// - `NewGologLogger()` requires an existing golog.Logger instance
// - Implements the same Logger interface as other loggers
// - Respects LangGraph log levels while using golog's formatting
// - Minimal wrapper - just forwards calls to the underlying golog logger
//
// # Custom Loggers
//
// You can implement the Logger interface for custom logging solutions:
//
// type CustomLogger struct {
// // Custom fields
// }
//
// func (l *CustomLogger) Debug(format string, v ...any) {
// // Custom debug implementation
// }
//
// func (l *CustomLogger) Info(format string, v ...any) {
// // Custom info implementation
// }
//
// func (l *CustomLogger) Warn(format string, v ...any) {
// // Custom warn implementation
// }
//
// func (l *CustomLogger) Error(format string, v ...any) {
// // Custom error implementation
// }
//
// # Best Practices
//
// 1. Use appropriate log levels - Debug for development, Info for operation flow,
// Warn for recoverable issues, Error for failures
//
// 2. Include context in log messages but avoid sensitive data
//
// 3. Consider structured logging formats for easier parsing in production
//
// 4. Rotate log files for long-running applications
//
// 5. Use conditional logging to avoid unnecessary string formatting:
//
// if logger.LevelEnabled(log.LogLevelDebug) {
// logger.Debug("Complex data: %+v", complexStruct)
// }
package log
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/log/logger.go | log/logger.go | package log
import (
"fmt"
"io"
"log"
"os"
)
// LogLevel represents logging severity
type LogLevel int
const (
// LogLevelDebug for detailed debugging information
LogLevelDebug LogLevel = iota
// LogLevelInfo for general informational messages
LogLevelInfo
// LogLevelWarn for warning messages
LogLevelWarn
// LogLevelError for error messages
LogLevelError
// LogLevelNone disables all logging
LogLevelNone
)
// Logger interface for PTC logging
type Logger interface {
Debug(format string, v ...any)
Info(format string, v ...any)
Warn(format string, v ...any)
Error(format string, v ...any)
}
// DefaultLogger implements Logger using Go's standard log package
type DefaultLogger struct {
logger *log.Logger
level LogLevel
}
// NewDefaultLogger creates a new default logger
func NewDefaultLogger(level LogLevel) *DefaultLogger {
return &DefaultLogger{
logger: log.New(os.Stderr, "[lango] ", log.LstdFlags),
level: level,
}
}
// NewCustomLogger creates a logger with custom output
func NewCustomLogger(out io.Writer, level LogLevel) *DefaultLogger {
return &DefaultLogger{
logger: log.New(out, "[lango] ", log.LstdFlags),
level: level,
}
}
// Debug logs debug messages
func (l *DefaultLogger) Debug(format string, v ...any) {
if l.level <= LogLevelDebug {
l.logger.Printf("[DEBUG] "+format, v...)
}
}
// Info logs informational messages
func (l *DefaultLogger) Info(format string, v ...any) {
if l.level <= LogLevelInfo {
l.logger.Printf("[INFO] "+format, v...)
}
}
// Warn logs warning messages
func (l *DefaultLogger) Warn(format string, v ...any) {
if l.level <= LogLevelWarn {
l.logger.Printf("[WARN] "+format, v...)
}
}
// Error logs error messages
func (l *DefaultLogger) Error(format string, v ...any) {
if l.level <= LogLevelError {
l.logger.Printf("[ERROR] "+format, v...)
}
}
// NoOpLogger is a logger that doesn't log anything
type NoOpLogger struct{}
// Debug does nothing
func (l *NoOpLogger) Debug(format string, v ...any) {}
// Info does nothing
func (l *NoOpLogger) Info(format string, v ...any) {}
// Warn does nothing
func (l *NoOpLogger) Warn(format string, v ...any) {}
// Error does nothing
func (l *NoOpLogger) Error(format string, v ...any) {}
// String returns the string representation of LogLevel
func (l LogLevel) String() string {
switch l {
case LogLevelDebug:
return "DEBUG"
case LogLevelInfo:
return "INFO"
case LogLevelWarn:
return "WARN"
case LogLevelError:
return "ERROR"
case LogLevelNone:
return "NONE"
default:
return fmt.Sprintf("UNKNOWN(%d)", l)
}
}
// Package-level logger (default is DefaultLogger with info level)
var defaultLogger Logger = NewDefaultLogger(LogLevelInfo)
// SetDefaultLogger sets the package-level logger
// This allows users to enable logging globally without passing logger objects around
func SetDefaultLogger(logger Logger) {
defaultLogger = logger
}
// GetDefaultLogger returns the current package-level logger
func GetDefaultLogger() Logger {
return defaultLogger
}
// SetLogLevel creates and sets a default logger with the specified log level
// This is a convenience function for quick logging setup
func SetLogLevel(level LogLevel) {
defaultLogger = NewDefaultLogger(level)
}
// Debug logs a debug message using the package-level logger
func Debug(format string, v ...any) {
defaultLogger.Debug(format, v...)
}
// Info logs an informational message using the package-level logger
func Info(format string, v ...any) {
defaultLogger.Info(format, v...)
}
// Warn logs a warning message using the package-level logger
func Warn(format string, v ...any) {
defaultLogger.Warn(format, v...)
}
// Error logs an error message using the package-level logger
func Error(format string, v ...any) {
defaultLogger.Error(format, v...)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/log/logger_test.go | log/logger_test.go | package log
import (
"bytes"
"strings"
"testing"
)
// TestDefaultLogger tests the default logger functionality
func TestDefaultLogger(t *testing.T) {
var buf bytes.Buffer
logger := NewCustomLogger(&buf, LogLevelDebug)
logger.Debug("debug message")
logger.Info("info message")
logger.Warn("warn message")
logger.Error("error message")
output := buf.String()
expectedMessages := []string{
"[DEBUG] debug message",
"[INFO] info message",
"[WARN] warn message",
"[ERROR] error message",
}
for _, expected := range expectedMessages {
if !strings.Contains(output, expected) {
t.Errorf("Expected output to contain '%s', got: %s", expected, output)
}
}
}
// TestLogLevels tests different log levels
func TestLogLevels(t *testing.T) {
tests := []struct {
name string
level LogLevel
shouldContain []string
shouldNotContain []string
}{
{
name: "Debug level",
level: LogLevelDebug,
shouldContain: []string{"[DEBUG]", "[INFO]", "[WARN]", "[ERROR]"},
},
{
name: "Info level",
level: LogLevelInfo,
shouldContain: []string{"[INFO]", "[WARN]", "[ERROR]"},
shouldNotContain: []string{"[DEBUG]"},
},
{
name: "Warn level",
level: LogLevelWarn,
shouldContain: []string{"[WARN]", "[ERROR]"},
shouldNotContain: []string{"[DEBUG]", "[INFO]"},
},
{
name: "Error level",
level: LogLevelError,
shouldContain: []string{"[ERROR]"},
shouldNotContain: []string{"[DEBUG]", "[INFO]", "[WARN]"},
},
{
name: "None level",
level: LogLevelNone,
shouldNotContain: []string{"[DEBUG]", "[INFO]", "[WARN]", "[ERROR]"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var buf bytes.Buffer
logger := NewCustomLogger(&buf, tt.level)
logger.Debug("debug")
logger.Info("info")
logger.Warn("warn")
logger.Error("error")
output := buf.String()
for _, expected := range tt.shouldContain {
if !strings.Contains(output, expected) {
t.Errorf("Expected output to contain '%s'", expected)
}
}
for _, unexpected := range tt.shouldNotContain {
if strings.Contains(output, unexpected) {
t.Errorf("Expected output NOT to contain '%s', got: %s", unexpected, output)
}
}
})
}
}
// TestNoOpLogger tests that NoOpLogger doesn't produce any output
func TestNoOpLogger(t *testing.T) {
logger := &NoOpLogger{}
// These should not panic
logger.Debug("test")
logger.Info("test")
logger.Warn("test")
logger.Error("test")
}
// TestLogLevelString tests LogLevel.String()
func TestLogLevelString(t *testing.T) {
tests := []struct {
level LogLevel
expected string
}{
{LogLevelDebug, "DEBUG"},
{LogLevelInfo, "INFO"},
{LogLevelWarn, "WARN"},
{LogLevelError, "ERROR"},
{LogLevelNone, "NONE"},
{LogLevel(999), "UNKNOWN(999)"},
}
for _, tt := range tests {
if got := tt.level.String(); got != tt.expected {
t.Errorf("LogLevel(%d).String() = %s, want %s", tt.level, got, tt.expected)
}
}
}
// TestNewDefaultLogger tests creating a default logger
func TestNewDefaultLogger(t *testing.T) {
logger := NewDefaultLogger(LogLevelInfo)
if logger == nil {
t.Error("NewDefaultLogger returned nil")
}
}
// TestPackageLevelFunctions tests package-level logging functions
func TestPackageLevelFunctions(t *testing.T) {
// Save original logger
originalLogger := defaultLogger
defer func() {
defaultLogger = originalLogger
}()
// Test with custom logger
var buf bytes.Buffer
SetDefaultLogger(NewCustomLogger(&buf, LogLevelDebug))
Debug("debug %s", "msg")
Info("info %s", "msg")
Warn("warn %s", "msg")
Error("error %s", "msg")
output := buf.String()
expectedMessages := []string{
"[DEBUG] debug msg",
"[INFO] info msg",
"[WARN] warn msg",
"[ERROR] error msg",
}
for _, expected := range expectedMessages {
if !strings.Contains(output, expected) {
t.Errorf("Expected output to contain '%s', got: %s", expected, output)
}
}
}
// TestSetLogLevel tests SetLogLevel convenience function
func TestSetLogLevel(t *testing.T) {
// Save original logger
originalLogger := defaultLogger
defer func() {
defaultLogger = originalLogger
}()
SetLogLevel(LogLevelInfo)
// Verify the logger is set (we can't directly check the type, but we can test behavior)
// This is implicitly tested by the package level functions test above
}
// TestPackageLevelNoOp tests that package-level functions don't panic with default NoOpLogger
func TestPackageLevelNoOp(t *testing.T) {
// Save original logger
originalLogger := defaultLogger
defer func() {
defaultLogger = originalLogger
}()
// Reset to NoOpLogger
SetDefaultLogger(&NoOpLogger{})
// These should not panic
Debug("test")
Info("test")
Warn("test")
Error("test")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/python_tool.go | tool/python_tool.go | package tool
import (
"bytes"
"fmt"
"os"
"os/exec"
"text/template"
)
type PythonTool struct {
}
func (t *PythonTool) Run(args map[string]any, code string) (string, error) {
tmpl, err := template.New("python").Parse(code)
if err != nil {
return "", fmt.Errorf("failed to parse python template: %w", err)
}
var script bytes.Buffer
err = tmpl.Execute(&script, args)
if err != nil {
return "", fmt.Errorf("failed to execute python template: %w", err)
}
tmpfile, err := os.CreateTemp("", "python-*.py")
if err != nil {
return "", fmt.Errorf("failed to create temp file: %w", err)
}
defer os.Remove(tmpfile.Name())
if _, err := tmpfile.Write(script.Bytes()); err != nil {
return "", fmt.Errorf("failed to write to temp file: %w", err)
}
if err := tmpfile.Close(); err != nil {
return "", fmt.Errorf("failed to close temp file: %w", err)
}
return RunPythonScript(tmpfile.Name(), nil)
}
// RunPythonScript executes a Python script and returns its combined stdout and stderr.
// It tries to use 'python3' first, then falls back to 'python'.
func RunPythonScript(scriptPath string, args []string) (string, error) {
pythonExe, err := exec.LookPath("python3")
if err != nil {
pythonExe, err = exec.LookPath("python")
if err != nil {
return "", fmt.Errorf("failed to find python3 or python in PATH: %w", err)
}
}
cmd := exec.Command(pythonExe, append([]string{scriptPath}, args...)...)
cmd.Env = os.Environ()
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
if err != nil {
return "", fmt.Errorf("failed to run python script '%s' with '%s': %w\nStdout: %s\nStderr: %s", scriptPath, pythonExe, err, stdout.String(), stderr.String())
}
return stdout.String() + stderr.String(), nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/tools_uncovered_test.go | tool/tools_uncovered_test.go | package tool
import (
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// Tests for file_tool.go
func TestReadFile(t *testing.T) {
// Create a temporary file for testing
tmpDir := t.TempDir()
testFile := filepath.Join(tmpDir, "test.txt")
testContent := "Hello, World!\nThis is a test file."
// Write test content to file
err := os.WriteFile(testFile, []byte(testContent), 0644)
require.NoError(t, err)
// Test reading the file
content, err := ReadFile(testFile)
assert.NoError(t, err)
assert.Equal(t, testContent, content)
// Test reading non-existent file
_, err = ReadFile(filepath.Join(tmpDir, "nonexistent.txt"))
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to read file")
}
func TestWriteFile(t *testing.T) {
tmpDir := t.TempDir()
testFile := filepath.Join(tmpDir, "write_test.txt")
testContent := "This is test content for writing."
// Test writing to a new file
err := WriteFile(testFile, testContent)
assert.NoError(t, err)
// Verify the content was written
content, err := os.ReadFile(testFile)
assert.NoError(t, err)
assert.Equal(t, testContent, string(content))
// Test overwriting an existing file
newContent := "Overwritten content"
err = WriteFile(testFile, newContent)
assert.NoError(t, err)
// Verify the content was overwritten
content, err = os.ReadFile(testFile)
assert.NoError(t, err)
assert.Equal(t, newContent, string(content))
// Test writing to an invalid path (directory that doesn't exist)
invalidPath := filepath.Join(tmpDir, "nonexistent", "file.txt")
err = WriteFile(invalidPath, "test")
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to write to file")
}
// Tests for knowledge_tool.go
func TestWikipediaSearch(t *testing.T) {
t.Skip("Skipping Wikipedia search test - requires external API access and may be rate-limited")
// Note: This test is skipped because it relies on the external Wikipedia API
// which may return 403 errors due to rate limiting or other restrictions.
// The mock server below is not currently used because WikipediaSearch
// has a hardcoded URL. To properly test this, WikipediaSearch would need
// to accept a base URL parameter.
// Mock Wikipedia API server (currently not used due to hardcoded URL)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/w/api.php" {
http.Error(w, "Not found", http.StatusNotFound)
return
}
// Check if it's a Wikipedia API request
if r.URL.Query().Get("action") != "query" {
http.Error(w, "Bad request", http.StatusBadRequest)
return
}
// Return mock Wikipedia response
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{
"query": {
"pages": {
"12345": {
"extract": "Python is a high-level programming language."
}
}
}
}`))
}))
defer server.Close()
// Test successful search
// We can't easily mock the base URL, so we'll test with a real simple request
// that might fail but won't crash
result, err := WikipediaSearch("NonExistentPageForTesting12345")
// Either it succeeds or returns a "not found" message, both are acceptable
if err != nil {
t.Logf("Wikipedia search failed (expected in test environment): %v", err)
} else {
t.Logf("Wikipedia search result: %s", result)
}
}
func TestWikipediaSearchInvalidResponse(t *testing.T) {
// Mock server returning invalid JSON
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{invalid json}`))
}))
defer server.Close()
// This test would require modifying WikipediaSearch to accept a base URL parameter
// For now, we just verify the function doesn't panic
_ = func() {
// This would fail in real scenario but shouldn't panic
_, _ = WikipediaSearch("test")
}
}
// Tests for python_tool.go
func TestPythonTool(t *testing.T) {
// Skip if python is not available
if _, err := os.Stat("/usr/bin/python3"); os.IsNotExist(err) {
if _, err := os.Stat("/usr/bin/python"); os.IsNotExist(err) {
t.Skip("Python not available, skipping tests")
}
}
tool := &PythonTool{}
// Test simple Python execution
result, err := tool.Run(map[string]any{}, "print('Hello from Python')")
assert.NoError(t, err)
assert.Contains(t, result, "Hello from Python")
// Test Python with template variables
result, err = tool.Run(map[string]any{"Name": "World"}, `print("Hello, {{.Name}}!")`)
assert.NoError(t, err)
assert.Contains(t, result, "Hello, World!")
// Test Python with syntax error
_, err = tool.Run(map[string]any{}, "print('unclosed string")
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to run python script")
// Test invalid template
_, err = tool.Run(map[string]any{}, "print('{{.Invalid")
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to parse python template")
}
func TestRunPythonScript(t *testing.T) {
// Skip if python is not available
if _, err := os.Stat("/usr/bin/python3"); os.IsNotExist(err) {
if _, err := os.Stat("/usr/bin/python"); os.IsNotExist(err) {
t.Skip("Python not available, skipping tests")
}
}
// Create a simple Python script
tmpDir := t.TempDir()
scriptPath := filepath.Join(tmpDir, "test.py")
err := os.WriteFile(scriptPath, []byte("print('Test output')"), 0644)
require.NoError(t, err)
// Test running the script
result, err := RunPythonScript(scriptPath, nil)
assert.NoError(t, err)
assert.Contains(t, result, "Test output")
// Test running with arguments
scriptPathWithArgs := filepath.Join(tmpDir, "test_args.py")
err = os.WriteFile(scriptPathWithArgs, []byte(`
import sys
print(f"Args: {sys.argv[1:]}")
`), 0644)
require.NoError(t, err)
result, err = RunPythonScript(scriptPathWithArgs, []string{"arg1", "arg2"})
assert.NoError(t, err)
assert.Contains(t, result, "Args: ['arg1', 'arg2']")
// Test running non-existent script
_, err = RunPythonScript(filepath.Join(tmpDir, "nonexistent.py"), nil)
assert.Error(t, err)
}
// Tests for shell_tool.go
func TestShellTool(t *testing.T) {
// Skip if bash is not available
if _, err := os.Stat("/bin/bash"); os.IsNotExist(err) {
t.Skip("Bash not available, skipping tests")
}
tool := &ShellTool{}
// Test simple shell command
result, err := tool.Run(map[string]any{}, "echo 'Hello from shell'")
assert.NoError(t, err)
assert.Contains(t, result, "Hello from shell")
// Test shell with template variables
result, err = tool.Run(map[string]any{"Name": "World"}, `echo "Hello, {{.Name}}!"`)
assert.NoError(t, err)
assert.Contains(t, result, "Hello, World!")
// Test shell command that fails
_, err = tool.Run(map[string]any{}, "exit 1")
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to run shell script")
// Test invalid template
_, err = tool.Run(map[string]any{}, "echo '{{.Invalid")
assert.Error(t, err)
assert.Contains(t, err.Error(), "failed to parse shell template")
}
func TestRunShellScript(t *testing.T) {
// Skip if bash is not available
if _, err := os.Stat("/bin/bash"); os.IsNotExist(err) {
t.Skip("Bash not available, skipping tests")
}
// Create a simple shell script
tmpDir := t.TempDir()
scriptPath := filepath.Join(tmpDir, "test.sh")
err := os.WriteFile(scriptPath, []byte("#!/bin/bash\necho 'Test output'"), 0755)
require.NoError(t, err)
// Test running the script
result, err := RunShellScript(scriptPath, nil)
assert.NoError(t, err)
assert.Contains(t, result, "Test output")
// Test running with arguments
scriptPathWithArgs := filepath.Join(tmpDir, "test_args.sh")
err = os.WriteFile(scriptPathWithArgs, []byte(`#!/bin/bash
echo "Args: $@"`), 0755)
require.NoError(t, err)
result, err = RunShellScript(scriptPathWithArgs, []string{"arg1", "arg2"})
assert.NoError(t, err)
assert.Contains(t, result, "Args: arg1 arg2")
// Test running non-existent script
_, err = RunShellScript(filepath.Join(tmpDir, "nonexistent.sh"), nil)
assert.Error(t, err)
}
// Tests for web_search_tool.go
// Tests for web_tool.go
func TestWebFetch(t *testing.T) {
// Mock web server
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
w.Write([]byte(`<!DOCTYPE html>
<html>
<head>
<title>Test Page</title>
<script>console.log('test');</script>
<style>body { color: blue; }</style>
</head>
<body>
<h1>Test Content</h1>
<p>This is a test paragraph.</p>
<script>alert('test');</script>
</body>
</html>`))
}))
defer server.Close()
// Test successful fetch
result, err := WebFetch(server.URL)
assert.NoError(t, err)
assert.Contains(t, result, "Test Content")
assert.Contains(t, result, "This is a test paragraph")
// Scripts and styles should be removed by goquery
assert.NotContains(t, result, "console.log")
assert.NotContains(t, result, "color: blue")
// Test fetch with error status
errorServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotFound)
}))
defer errorServer.Close()
_, err = WebFetch(errorServer.URL)
assert.Error(t, err)
assert.Contains(t, err.Error(), "status code 404")
// Test fetch of non-existent URL
_, err = WebFetch("http://nonexistent-domain-for-testing.local")
assert.Error(t, err)
// Test fetch of URL with no body content
emptyServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/html")
w.Write([]byte("<html><body></body></html>"))
}))
defer emptyServer.Close()
_, err = WebFetch(emptyServer.URL)
assert.Error(t, err)
assert.Contains(t, err.Error(), "no text content found")
}
func TestWebFetchInvalidURL(t *testing.T) {
_, err := WebFetch("invalid-url")
assert.Error(t, err)
// The error could be "failed to create request" or "failed to fetch URL"
assert.True(t,
strings.Contains(err.Error(), "failed to create request") ||
strings.Contains(err.Error(), "failed to fetch URL"),
"Expected error message to contain 'failed to create request' or 'failed to fetch URL', got: %v", err)
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/brave.go | tool/brave.go | package tool
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/url"
"os"
"strings"
)
// BraveSearch is a tool that uses the Brave Search API to search the web.
type BraveSearch struct {
APIKey string
BaseURL string
Count int
Country string
Lang string
}
type BraveOption func(*BraveSearch)
// WithBraveBaseURL sets the base URL for the Brave Search API.
func WithBraveBaseURL(baseURL string) BraveOption {
return func(b *BraveSearch) {
b.BaseURL = baseURL
}
}
// WithBraveCount sets the number of results to return (1-20).
func WithBraveCount(count int) BraveOption {
return func(b *BraveSearch) {
if count < 1 {
count = 1
}
if count > 20 {
count = 20
}
b.Count = count
}
}
// WithBraveCountry sets the country code for search results (e.g., "US", "CN").
func WithBraveCountry(country string) BraveOption {
return func(b *BraveSearch) {
b.Country = country
}
}
// WithBraveLang sets the language code for search results (e.g., "en", "zh").
func WithBraveLang(lang string) BraveOption {
return func(b *BraveSearch) {
b.Lang = lang
}
}
// NewBraveSearch creates a new BraveSearch tool.
// If apiKey is empty, it tries to read from BRAVE_API_KEY environment variable.
func NewBraveSearch(apiKey string, opts ...BraveOption) (*BraveSearch, error) {
if apiKey == "" {
apiKey = os.Getenv("BRAVE_API_KEY")
}
if apiKey == "" {
return nil, fmt.Errorf("BRAVE_API_KEY not set")
}
b := &BraveSearch{
APIKey: apiKey,
BaseURL: "https://api.search.brave.com/res/v1/web/search",
Count: 10,
Country: "US",
Lang: "en",
}
for _, opt := range opts {
opt(b)
}
return b, nil
}
// Name returns the name of the tool.
func (b *BraveSearch) Name() string {
return "Brave_Search"
}
// Description returns the description of the tool.
func (b *BraveSearch) Description() string {
return "A privacy-focused search engine powered by Brave. " +
"Useful for finding current information and answering questions. " +
"Input should be a search query."
}
// Call executes the search.
func (b *BraveSearch) Call(ctx context.Context, input string) (string, error) {
// Build query parameters
params := url.Values{}
params.Set("q", input)
params.Set("count", fmt.Sprintf("%d", b.Count))
if b.Country != "" {
params.Set("country", b.Country)
}
if b.Lang != "" {
params.Set("search_lang", b.Lang)
}
// Create request URL
reqURL := fmt.Sprintf("%s?%s", b.BaseURL, params.Encode())
req, err := http.NewRequestWithContext(ctx, "GET", reqURL, nil)
if err != nil {
return "", fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Accept", "application/json")
req.Header.Set("X-Subscription-Token", b.APIKey)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("brave api returned status: %d", resp.StatusCode)
}
var result map[string]any
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return "", fmt.Errorf("failed to decode response: %w", err)
}
// Format the output
var sb strings.Builder
// Extract web results
if web, ok := result["web"].(map[string]any); ok {
if results, ok := web["results"].([]any); ok {
for i, r := range results {
if item, ok := r.(map[string]any); ok {
title, _ := item["title"].(string)
url, _ := item["url"].(string)
description, _ := item["description"].(string)
sb.WriteString(fmt.Sprintf("%d. Title: %s\nURL: %s\nDescription: %s\n\n",
i+1, title, url, description))
}
}
}
}
if sb.Len() == 0 {
return "No results found", nil
}
return sb.String(), nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/bocha.go | tool/bocha.go | package tool
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"os"
"strings"
)
// BochaSearch is a tool that uses the Bocha API to search the web.
type BochaSearch struct {
APIKey string
BaseURL string
Count int
Freshness string
Summary bool
}
type BochaOption func(*BochaSearch)
// WithBochaBaseURL sets the base URL for the Bocha API.
func WithBochaBaseURL(url string) BochaOption {
return func(b *BochaSearch) {
b.BaseURL = url
}
}
// WithBochaCount sets the number of results to return.
func WithBochaCount(count int) BochaOption {
return func(b *BochaSearch) {
b.Count = count
}
}
// WithBochaFreshness sets the freshness filter for the search.
// Valid values: "oneDay", "oneWeek", "oneMonth", "oneYear", "noLimit".
func WithBochaFreshness(freshness string) BochaOption {
return func(b *BochaSearch) {
b.Freshness = freshness
}
}
// WithBochaSummary sets whether to return a summary.
func WithBochaSummary(summary bool) BochaOption {
return func(b *BochaSearch) {
b.Summary = summary
}
}
// NewBochaSearch creates a new BochaSearch tool.
// If apiKey is empty, it tries to read from BOCHA_API_KEY environment variable.
func NewBochaSearch(apiKey string, opts ...BochaOption) (*BochaSearch, error) {
if apiKey == "" {
apiKey = os.Getenv("BOCHA_API_KEY")
}
if apiKey == "" {
return nil, fmt.Errorf("BOCHA_API_KEY not set")
}
b := &BochaSearch{
APIKey: apiKey,
BaseURL: "https://api.bochaai.com/v1/web-search",
Count: 10,
Freshness: "noLimit",
Summary: true,
}
for _, opt := range opts {
opt(b)
}
return b, nil
}
// Name returns the name of the tool.
func (b *BochaSearch) Name() string {
return "Bocha_Search"
}
// Description returns the description of the tool.
func (b *BochaSearch) Description() string {
return "A search engine powered by Bocha AI. " +
"Useful for finding real-time information and answering questions. " +
"Input should be a search query."
}
// Call executes the search.
func (b *BochaSearch) Call(ctx context.Context, input string) (string, error) {
reqBody := map[string]any{
"query": input,
"count": b.Count,
"freshness": b.Freshness,
"summary": b.Summary,
}
jsonBody, err := json.Marshal(reqBody)
if err != nil {
return "", fmt.Errorf("failed to marshal request body: %w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", b.BaseURL, bytes.NewBuffer(jsonBody))
if err != nil {
return "", fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer "+b.APIKey)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("bocha api returned status: %d", resp.StatusCode)
}
var result map[string]any
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return "", fmt.Errorf("failed to decode response: %w", err)
}
// Format the output
// Assuming the response structure based on common patterns and search results:
// { "data": { "webPages": { "value": [ ... ] } } } or similar.
// Since I don't have the exact structure, I'll try to handle a generic "results" or "webPages" field if possible,
// or dump the JSON if structure is unknown.
// However, based on the search result, it returns structured results.
// Let's assume a structure similar to:
// {
// "data": {
// "webPages": {
// "value": [
// { "name": "Title", "url": "URL", "snippet": "Summary" }
// ]
// }
// }
// }
// Or maybe just a list at the top level?
// Given the uncertainty, I will try to parse a few common fields.
var sb strings.Builder
// Helper function to extract and format items
formatItems := func(items []any) {
for _, item := range items {
if m, ok := item.(map[string]any); ok {
title, _ := m["name"].(string)
if title == "" {
title, _ = m["title"].(string)
}
url, _ := m["url"].(string)
snippet, _ := m["snippet"].(string)
if snippet == "" {
snippet, _ = m["summary"].(string)
}
if snippet == "" {
snippet, _ = m["content"].(string)
}
sb.WriteString(fmt.Sprintf("Title: %s\nURL: %s\nContent: %s\n\n", title, url, snippet))
}
}
}
// Try to find the list of results
if data, ok := result["data"].(map[string]any); ok {
if webPages, ok := data["webPages"].(map[string]any); ok {
if value, ok := webPages["value"].([]any); ok {
formatItems(value)
return sb.String(), nil
}
}
}
// Fallback: check if "results" exists at top level (like Tavily)
if results, ok := result["results"].([]any); ok {
formatItems(results)
return sb.String(), nil
}
// Fallback: check if "webPages" exists at top level
if webPages, ok := result["webPages"].(map[string]any); ok {
if value, ok := webPages["value"].([]any); ok {
formatItems(value)
return sb.String(), nil
}
}
// If we can't parse it nicely, return the raw JSON (indented)
formattedJSON, _ := json.MarshalIndent(result, "", " ")
return string(formattedJSON), nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/definitions.go | tool/definitions.go | package tool
import (
openai "github.com/sashabaranov/go-openai"
)
// GetBaseTools returns the list of base tools available to all skills.
func GetBaseTools() []openai.Tool {
return []openai.Tool{
{
Type: openai.ToolTypeFunction,
Function: &openai.FunctionDefinition{
Name: "run_shell_code",
Description: "Executes a shell code snippet and returns its combined stdout and stderr.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"code": map[string]any{
"type": "string",
"description": "The shell code snippet to execute.",
},
"args": map[string]any{
"type": "object",
"description": "A map of key-value pairs to pass to the code.",
},
},
"required": []string{"code"},
},
},
},
{
Type: openai.ToolTypeFunction,
Function: &openai.FunctionDefinition{
Name: "run_shell_script",
Description: "Executes a shell script and returns its combined stdout and stderr. Use this for general shell commands.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"scriptPath": map[string]any{
"type": "string",
"description": "The path to the shell script to execute.",
},
"args": map[string]any{
"type": "array",
"description": "A list of string arguments to pass to the script.",
"items": map[string]any{
"type": "string",
},
},
},
"required": []string{"scriptPath"},
},
},
},
{
Type: openai.ToolTypeFunction,
Function: &openai.FunctionDefinition{
Name: "run_python_code",
Description: "Executes a Python code snippet and returns its combined stdout and stderr.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"code": map[string]any{
"type": "string",
"description": "The Python code snippet to execute.",
},
"args": map[string]any{
"type": "object",
"description": "A map of key-value pairs to pass to the code.",
},
},
"required": []string{"code"},
},
},
},
{
Type: openai.ToolTypeFunction,
Function: &openai.FunctionDefinition{
Name: "run_python_script",
Description: "Executes a Python script and returns its combined stdout and stderr.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"scriptPath": map[string]any{
"type": "string",
"description": "The path to the Python script to execute.",
},
"args": map[string]any{
"type": "array",
"description": "A list of string arguments to pass to the script.",
"items": map[string]any{
"type": "string",
},
},
},
"required": []string{"scriptPath"},
},
},
},
{
Type: openai.ToolTypeFunction,
Function: &openai.FunctionDefinition{
Name: "read_file",
Description: "Reads the content of a file and returns it as a string.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"filePath": map[string]any{
"type": "string",
"description": "The path to the file to read.",
},
},
"required": []string{"filePath"},
},
},
},
{
Type: openai.ToolTypeFunction,
Function: &openai.FunctionDefinition{
Name: "write_file",
Description: "Writes the given content to a file. If the file does not exist, it will be created. If it exists, its content will be truncated.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"filePath": map[string]any{
"type": "string",
"description": "The path to the file to write.",
},
"content": map[string]any{
"type": "string",
"description": "The content to write to the file.",
},
},
"required": []string{"filePath", "content"},
},
},
},
{
Type: openai.ToolTypeFunction,
Function: &openai.FunctionDefinition{
Name: "wikipedia_search",
Description: "Performs a search on Wikipedia for the given query and returns a summary of the relevant entry.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"query": map[string]any{
"type": "string",
"description": "The search query for Wikipedia.",
},
},
"required": []string{"query"},
},
},
},
{
Type: openai.ToolTypeFunction,
Function: &openai.FunctionDefinition{
Name: "tavily_search",
Description: "Performs a web search using the Tavily API for the given query and returns a summary of results.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"query": map[string]any{
"type": "string",
"description": "The search query.",
},
},
"required": []string{"query"},
},
},
},
// {
// Type: openai.ToolTypeFunction,
// Function: &openai.FunctionDefinition{
// Name: "web_fetch",
// Description: "Fetches the clean text content from a given URL. It automatically parses the HTML and returns only the readable text.",
// Parameters: map[string]any{
// "type": "object",
// "properties": map[string]any{
// "url": map[string]any{
// "type": "string",
// "description": "The full URL to fetch, including the protocol (e.g., 'https://example.com').",
// },
// },
// "required": []string{"url"},
// },
// },
// },
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/knowledge_tool.go | tool/knowledge_tool.go | package tool
import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"strings"
"time"
)
// WikipediaSearch performs a search on Wikipedia for the given query and returns a summary.
// It uses the Wikipedia API.
func WikipediaSearch(query string) (string, error) {
baseURL := "https://en.wikipedia.org/w/api.php"
params := url.Values{}
params.Add("action", "query")
params.Add("format", "json")
params.Add("prop", "extracts")
params.Add("exintro", "") // Return only content before the first section
params.Add("explaintext", "") // Return plain text
params.Add("redirects", "1") // Resolve redirects
params.Add("titles", query)
searchURL := baseURL + "?" + params.Encode()
client := http.Client{
Timeout: 10 * time.Second,
}
req, err := http.NewRequestWithContext(context.Background(), "GET", searchURL, nil)
if err != nil {
return "", fmt.Errorf("failed to create request: %w", err)
}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("failed to perform Wikipedia search: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("Wikipedia API returned status %d", resp.StatusCode)
}
body, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("failed to read response body: %w", err)
}
var result struct {
Query struct {
Pages map[string]struct {
Extract string `json:"extract"`
} `json:"pages"`
} `json:"query"`
}
if err := json.Unmarshal(body, &result); err != nil {
return "", fmt.Errorf("failed to unmarshal Wikipedia response: %w", err)
}
for _, page := range result.Query.Pages {
if page.Extract != "" {
// Clean up some common Wikipedia API artifacts
extract := strings.ReplaceAll(page.Extract, "(listen)", "")
extract = strings.TrimSpace(extract)
return extract, nil
}
}
return "No relevant Wikipedia entry found.", nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/web_tool.go | tool/web_tool.go | package tool
import (
"fmt"
"net/http"
"time"
"github.com/PuerkitoBio/goquery"
)
// WebFetch retrieves the main text content from a given URL.
// It uses goquery to parse the HTML and extract text, removing script and style tags.
func WebFetch(urlString string) (string, error) {
client := http.Client{
Timeout: 20 * time.Second,
}
req, err := http.NewRequest("GET", urlString, nil)
if err != nil {
return "", fmt.Errorf("failed to create request for %s: %w", urlString, err)
}
// Set a realistic User-Agent
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36")
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("failed to fetch URL %s: %w", urlString, err)
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return "", fmt.Errorf("request to %s failed with status code %d", urlString, resp.StatusCode)
}
// Parse the HTML document
doc, err := goquery.NewDocumentFromReader(resp.Body)
if err != nil {
return "", fmt.Errorf("failed to parse HTML from %s: %w", urlString, err)
}
// Remove script and style elements
doc.Find("script, style").Each(func(i int, s *goquery.Selection) {
s.Remove()
})
// Get the text from the body
bodyText := doc.Find("body").Text()
if bodyText == "" {
return "", fmt.Errorf("no text content found in the body of %s", urlString)
}
// Clean up whitespace
// return strings.Join(strings.Fields(bodyText), " ")
return bodyText, nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/shell_tool.go | tool/shell_tool.go | package tool
import (
"bytes"
"fmt"
"os"
"os/exec"
"text/template"
)
type ShellTool struct {
}
func (t *ShellTool) Run(args map[string]any, code string) (string, error) {
tmpl, err := template.New("shell").Parse(code)
if err != nil {
return "", fmt.Errorf("failed to parse shell template: %w", err)
}
var script bytes.Buffer
err = tmpl.Execute(&script, args)
if err != nil {
return "", fmt.Errorf("failed to execute shell template: %w", err)
}
tmpfile, err := os.CreateTemp("", "shell-*.sh")
if err != nil {
return "", fmt.Errorf("failed to create temp file: %w", err)
}
defer os.Remove(tmpfile.Name())
if _, err := tmpfile.Write(script.Bytes()); err != nil {
return "", fmt.Errorf("failed to write to temp file: %w", err)
}
if err := tmpfile.Close(); err != nil {
return "", fmt.Errorf("failed to close temp file: %w", err)
}
return RunShellScript(tmpfile.Name(), nil)
}
// RunShellScript executes a shell script and returns its combined stdout and stderr.
func RunShellScript(scriptPath string, args []string) (string, error) {
// nolint:gosec // G204: This is the intended functionality of the shell tool
cmd := exec.Command("bash", append([]string{scriptPath}, args...)...)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
if err != nil {
return "", fmt.Errorf("failed to run shell script '%s': %w\nStdout: %s\nStderr: %s", scriptPath, err, stdout.String(), stderr.String())
}
return stdout.String() + stderr.String(), nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/exa.go | tool/exa.go | package tool
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"os"
"strings"
)
// ExaSearch is a tool that uses the Exa API to search the web.
type ExaSearch struct {
APIKey string
BaseURL string
NumResults int
}
type ExaOption func(*ExaSearch)
// WithExaBaseURL sets the base URL for the Exa API.
func WithExaBaseURL(url string) ExaOption {
return func(t *ExaSearch) {
t.BaseURL = url
}
}
// WithExaNumResults sets the number of results to return.
func WithExaNumResults(num int) ExaOption {
return func(t *ExaSearch) {
t.NumResults = num
}
}
// NewExaSearch creates a new ExaSearch tool.
// If apiKey is empty, it tries to read from EXA_API_KEY environment variable.
func NewExaSearch(apiKey string, opts ...ExaOption) (*ExaSearch, error) {
if apiKey == "" {
apiKey = os.Getenv("EXA_API_KEY")
}
if apiKey == "" {
return nil, fmt.Errorf("EXA_API_KEY not set")
}
t := &ExaSearch{
APIKey: apiKey,
BaseURL: "https://api.exa.ai",
NumResults: 5,
}
for _, opt := range opts {
opt(t)
}
return t, nil
}
// Name returns the name of the tool.
func (t *ExaSearch) Name() string {
return "Exa_Search"
}
// Description returns the description of the tool.
func (t *ExaSearch) Description() string {
return "A search engine optimized for LLMs. " +
"Useful for finding high-quality content and answering questions. " +
"Input should be a search query."
}
// Call executes the search.
func (t *ExaSearch) Call(ctx context.Context, input string) (string, error) {
reqBody := map[string]any{
"query": input,
"numResults": t.NumResults,
"contents": map[string]any{
"text": true,
},
}
jsonBody, err := json.Marshal(reqBody)
if err != nil {
return "", fmt.Errorf("failed to marshal request body: %w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", t.BaseURL+"/search", bytes.NewBuffer(jsonBody))
if err != nil {
return "", fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("x-api-key", t.APIKey)
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("exa api returned status: %d", resp.StatusCode)
}
var result map[string]any
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return "", fmt.Errorf("failed to decode response: %w", err)
}
// Format the output
var sb strings.Builder
if results, ok := result["results"].([]any); ok {
for _, r := range results {
if item, ok := r.(map[string]any); ok {
title, _ := item["title"].(string)
url, _ := item["url"].(string)
text, _ := item["text"].(string)
// Truncate text if it's too long
if len(text) > 500 {
text = text[:500] + "..."
}
sb.WriteString(fmt.Sprintf("Title: %s\nURL: %s\nContent: %s\n\n", title, url, text))
}
}
}
return sb.String(), nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/doc.go | tool/doc.go | // Package tool provides a collection of ready-to-use tools for LangGraph Go agents.
//
// This package includes various tools that extend agent capabilities, including
// web search, file operations, code execution, and integration with popular
// APIs and services. Tools are designed to be easily integrated with prebuilt
// agents or custom implementations.
//
// # Available Tools
//
// ## Web Search Tools
//
// ### Tavily Search
// Perform web searches using the Tavily API:
//
// import "github.com/smallnest/langgraphgo/tool"
//
// searchTool, err := tool.NewTavilySearchTool("your-tavily-api-key")
// if err != nil {
// return err
// }
//
// // Use with an agent
// agent, _ := prebuilt.CreateReactAgent(llm, []tools.Tool{searchTool}, 10)
//
// // Or use directly
// result, err := searchTool.Call(ctx, `{
// "query": "latest developments in quantum computing",
// "max_results": 5
// }`)
//
// ### Brave Search
// Use Brave Search API for web searching:
//
// braveTool, err := tool.NewBraveSearchTool("your-brave-api-key")
// if err != nil {
// return err
// }
//
// ### Bocha Search
// Chinese search engine integration:
//
// bochaTool, err := tool.NewBochaSearchTool("your-bocha-api-key")
//
// ### EXA Search
// Advanced neural search with EXA:
//
// exaTool, err := tool.NewEXASearchTool("your-exa-api-key")
//
// ## File Operations
//
// ### File Tool
// Basic file system operations:
//
// fileTool := &tool.FileTool{}
//
// // Read a file
// result, _ := fileTool.Call(ctx, `{
// "action": "read",
// "path": "/path/to/file.txt"
// }`)
//
// // Write a file
// result, _ := fileTool.Call(ctx, `{
// "action": "write",
// "path": "/path/to/output.txt",
// "content": "Hello, World!"
// }`)
//
// // List directory
// result, _ := fileTool.Call(ctx, `{
// "action": "list",
// "path": "/path/to/directory"
// }`)
//
// ### Knowledge Tool
// Load and search knowledge bases:
//
// knowledgeTool := tool.NewKnowledgeTool("/path/to/knowledge")
//
// result, _ := knowledgeTool.Call(ctx, `{
// "query": "How to install LangGraph Go?",
// "max_results": 3
// }`)
//
// ## Code Execution
//
// ### Shell Tool
// Execute shell commands and scripts:
//
// // Execute shell code
// shellTool := &tool.ShellTool{}
// result, _ := shellTool.Call(ctx, `{
// "code": "ls -la /home/user"
// }`)
//
// // Execute with arguments
// result, _ := shellTool.Call(ctx, `{
// "code": "echo $1 $2",
// "args": {"Hello", "World"}
// }`)
//
// ### Python Tool
// Execute Python code:
//
// pythonTool := &tool.PythonTool{}
// result, _ := pythonTool.Call(ctx, `{
// "code": "import math; print(math.sqrt(16))"
// }`)
//
// // With imports and global variables
// result, _ := pythonTool.Call(ctx, `{
// "code": "print(data['value'] * 2)",
// "imports": ["numpy", "pandas"],
// "globals": {"value": 42}
// }`)
//
// ## Web Tools
//
// ### Web Tool
// Simple HTTP requests:
//
// webTool := &tool.WebTool{}
//
// // GET request
// result, _ := webTool.Call(ctx, `{
// "url": "https://api.example.com/data",
// "method": "GET"
// }`)
//
// // POST request with headers
// result, _ := webTool.Call(ctx, `{
// "url": "https://api.example.com/submit",
// "method": "POST",
// "headers": {"Content-Type": "application/json"},
// "body": "{\"key\": \"value\"}"
// }`)
//
// ### Web Search Tool
// Generic web search tool:
//
// searchTool := &tool.WebSearchTool{}
// result, _ := searchTool.Call(ctx, `{
// "query": "LangGraph Go documentation",
// "num_results": 5
// }`)
//
// # Tool Implementation
//
// ## Creating Custom Tools
//
// Implement the Tool interface:
//
// import (
// "github.com/tmc/langchaingo/tools"
// )
//
// type CustomTool struct {
// apiKey string
// }
//
// func (t *CustomTool) Name() string {
// return "custom_api_call"
// }
//
// func (t *CustomTool) Description() string {
// return "Makes a call to the custom API"
// }
//
// func (t *CustomTool) Call(ctx context.Context, input string) (string, error) {
// // Parse input
// var params struct {
// Query string `json:"query"`
// }
// if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
// return "", err
// }
//
// // Make API call
// result, err := t.callAPI(params.Query)
// if err != nil {
// return "", err
// }
//
// // Return result
// return json.Marshal(result)
// }
//
// # Tool Categories
//
// ## Base Tools
// Common tools available to all agents:
//
// baseTools := tool.GetBaseTools()
// // Includes:
// // - run_shell_code: Execute shell code
// // - run_shell_script: Execute shell script
// // - run_python_code: Execute Python code
// // - web_search: Perform web search
// // - file_operations: File system operations
//
// ## Specialized Tools
// Tools for specific domains:
//
// // Search tools
// tavilyTool, _ := tool.NewTavilySearchTool(apiKey)
// braveTool, _ := tool.NewBraveSearchTool(apiKey)
// exaTool, _ := tool.NewEXASearchTool(apiKey)
// bochaTool, _ := tool.NewBochaSearchTool(apiKey)
//
// // Execution tools
// shellTool := &tool.ShellTool{}
// pythonTool := &tool.PythonTool{}
// fileTool := &tool.FileTool{}
//
// // Web tools
// webTool := &tool.WebTool{}
// webSearchTool := &tool.WebSearchTool{}
//
// # Integration Examples
//
// ## With ReAct Agent
//
// // Combine multiple tools
// tools := []tools.Tool{
// &tool.ShellTool{},
// &tool.FileTool{},
// searchTool,
// pythonTool,
// }
//
// agent, _ := prebuilt.CreateReactAgent(llm, tools, 15)
//
// ## With PTC Agent
//
// ptcTools := []tools.Tool{
// &tool.ShellTool{},
// &tool.PythonTool{},
// &tool.FileTool{},
// }
//
// ptcAgent, _ := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
// Model: llm,
// Tools: ptcTools,
// Language: ptc.LanguagePython,
// })
//
// # Tool Configuration
//
// Many tools support configuration:
//
// // Tavily with custom options
// tavilyTool, _ := tool.NewTavilySearchToolWithConfig(
// apiKey,
// tool.TavilyConfig{
// MaxResults: 10,
// SearchDepth: "advanced",
// IncludeRawContent: true,
// },
// )
//
// // Shell tool with allowed commands
// shellTool := tool.NewShellToolWithConfig(
// tool.ShellConfig{
// AllowedCommands: []string{"ls", "cat", "grep"},
// Timeout: 30 * time.Second,
// WorkingDir: "/safe/directory",
// },
// )
//
// # Security Considerations
//
// - Validate all tool inputs
// - Use chroot/sandboxing for code execution
// - Set timeouts for network operations
// - Restrict file system access
// - Sanitize shell commands
// - Use API keys securely
// - Monitor tool usage
//
// # Error Handling
//
// Tools provide structured error responses:
//
// type ToolError struct {
// Code string `json:"code"`
// Message string `json:"message"`
// Details any `json:"details,omitempty"`
// }
//
// result, err := tool.Call(ctx, input)
// if err != nil {
// var toolErr *ToolError
// if errors.As(err, &toolErr) {
// // Handle specific tool error
// fmt.Printf("Tool error: %s - %s\n", toolErr.Code, toolErr.Message)
// }
// }
//
// # Best Practices
//
// 1. Choose appropriate tools for your use case
// 2. Provide clear tool descriptions
// 3. Validate inputs before processing
// 4. Handle errors gracefully
// 5. Use timeouts for long-running operations
// 6. Monitor tool usage and performance
// 7. Secure sensitive operations
// 8. Test tools with various inputs
//
// # Tool Composition
//
// Tools can be composed for complex workflows:
//
// // Create a composite tool that uses multiple sub-tools
// type CompositeTool struct {
// searchTool *tool.WebSearchTool
// fileTool *tool.FileTool
// }
//
// func (t *CompositeTool) Call(ctx context.Context, input string) (string, error) {
// // Search for information
// searchResult, _ := t.searchTool.Call(ctx, input)
//
// // Save results to file
// saveResult, _ := t.fileTool.Call(ctx, map[string]any{
// "action": "write",
// "path": "/tmp/search_results.txt",
// "content": searchResult,
// })
//
// return saveResult, nil
// }
package tool
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/tool_test.go | tool/tool_test.go | package tool
import (
"context"
"net/http"
"net/http/httptest"
"os"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestTavilySearch_Interface(t *testing.T) {
os.Setenv("TAVILY_API_KEY", "test-key")
defer os.Unsetenv("TAVILY_API_KEY")
tool, err := NewTavilySearch("")
require.NoError(t, err)
assert.Equal(t, "Tavily_Search", tool.Name())
assert.NotEmpty(t, tool.Description())
}
func TestExaSearch_Interface(t *testing.T) {
os.Setenv("EXA_API_KEY", "test-key")
defer os.Unsetenv("EXA_API_KEY")
tool, err := NewExaSearch("")
require.NoError(t, err)
assert.Equal(t, "Exa_Search", tool.Name())
assert.NotEmpty(t, tool.Description())
}
// Helper to mock Tavily API
func mockTavilyServer() *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/search" {
http.Error(w, "Not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{
"results": [
{
"title": "Test Result",
"url": "http://example.com",
"content": "This is a test content."
}
]
}`))
}))
}
func TestTavilySearch_Call(t *testing.T) {
server := mockTavilyServer()
defer server.Close()
os.Setenv("TAVILY_API_KEY", "test-key")
defer os.Unsetenv("TAVILY_API_KEY")
tool, err := NewTavilySearch("", WithTavilyBaseURL(server.URL))
require.NoError(t, err)
result, err := tool.Call(context.Background(), "test query")
require.NoError(t, err)
assert.Contains(t, result, "Title: Test Result")
assert.Contains(t, result, "URL: http://example.com")
assert.Contains(t, result, "Content: This is a test content.")
}
// Helper to mock Exa API
func mockExaServer() *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/search" {
http.Error(w, "Not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{
"results": [
{
"title": "Exa Result",
"url": "http://exa.example.com",
"text": "This is exa content."
}
]
}`))
}))
}
func TestExaSearch_Call(t *testing.T) {
server := mockExaServer()
defer server.Close()
os.Setenv("EXA_API_KEY", "test-key")
defer os.Unsetenv("EXA_API_KEY")
tool, err := NewExaSearch("", WithExaBaseURL(server.URL))
require.NoError(t, err)
result, err := tool.Call(context.Background(), "test query")
require.NoError(t, err)
assert.Contains(t, result, "Title: Exa Result")
assert.Contains(t, result, "URL: http://exa.example.com")
assert.Contains(t, result, "Content: This is exa content.")
}
func TestBochaSearch_Interface(t *testing.T) {
os.Setenv("BOCHA_API_KEY", "test-key")
defer os.Unsetenv("BOCHA_API_KEY")
tool, err := NewBochaSearch("")
require.NoError(t, err)
assert.Equal(t, "Bocha_Search", tool.Name())
assert.NotEmpty(t, tool.Description())
}
// Helper to mock Bocha API
func mockBochaServer() *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/v1/web-search" {
http.Error(w, "Not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{
"data": {
"webPages": {
"value": [
{
"name": "Bocha Result",
"url": "http://bocha.example.com",
"snippet": "This is bocha content."
}
]
}
}
}`))
}))
}
func TestBochaSearch_Call(t *testing.T) {
server := mockBochaServer()
defer server.Close()
os.Setenv("BOCHA_API_KEY", "test-key")
defer os.Unsetenv("BOCHA_API_KEY")
tool, err := NewBochaSearch("", WithBochaBaseURL(server.URL+"/v1/web-search"))
require.NoError(t, err)
result, err := tool.Call(context.Background(), "test query")
require.NoError(t, err)
assert.Contains(t, result, "Title: Bocha Result")
assert.Contains(t, result, "URL: http://bocha.example.com")
assert.Contains(t, result, "Content: This is bocha content.")
}
func TestBraveSearch_Interface(t *testing.T) {
os.Setenv("BRAVE_API_KEY", "test-key")
defer os.Unsetenv("BRAVE_API_KEY")
tool, err := NewBraveSearch("")
require.NoError(t, err)
assert.Equal(t, "Brave_Search", tool.Name())
assert.NotEmpty(t, tool.Description())
}
// Helper to mock Brave API
func mockBraveServer() *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{
"web": {
"results": [
{
"title": "Brave Result",
"url": "http://brave.example.com",
"description": "This is brave content."
}
]
}
}`))
}))
}
func TestBraveSearch_Call(t *testing.T) {
server := mockBraveServer()
defer server.Close()
os.Setenv("BRAVE_API_KEY", "test-key")
defer os.Unsetenv("BRAVE_API_KEY")
tool, err := NewBraveSearch("", WithBraveBaseURL(server.URL))
require.NoError(t, err)
result, err := tool.Call(context.Background(), "test query")
require.NoError(t, err)
assert.Contains(t, result, "Title: Brave Result")
assert.Contains(t, result, "URL: http://brave.example.com")
assert.Contains(t, result, "Description: This is brave content.")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/file_tool.go | tool/file_tool.go | package tool
import (
"fmt"
"os"
)
// ReadFile reads the content of a file and returns it as a string.
func ReadFile(filePath string) (string, error) {
content, err := os.ReadFile(filePath)
if err != nil {
return "", fmt.Errorf("failed to read file '%s': %w", filePath, err)
}
return string(content), nil
}
// WriteFile writes the given content to a file.
// If the file does not exist, it will be created. If it exists, its content will be truncated.
func WriteFile(filePath string, content string) error {
err := os.WriteFile(filePath, []byte(content), 0600)
if err != nil {
return fmt.Errorf("failed to write to file '%s': %w", filePath, err)
}
return nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/tool/tavily.go | tool/tavily.go | package tool
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"os"
"strings"
)
// TavilySearch is a tool that uses the Tavily API to search the web.
type TavilySearch struct {
APIKey string
BaseURL string
SearchDepth string
}
type TavilyOption func(*TavilySearch)
// WithTavilyBaseURL sets the base URL for the Tavily API.
func WithTavilyBaseURL(url string) TavilyOption {
return func(t *TavilySearch) {
t.BaseURL = url
}
}
// WithTavilySearchDepth sets the search depth for the Tavily API.
// Valid values are "basic" and "advanced".
func WithTavilySearchDepth(depth string) TavilyOption {
return func(t *TavilySearch) {
t.SearchDepth = depth
}
}
// NewTavilySearch creates a new TavilySearch tool.
// If apiKey is empty, it tries to read from TAVILY_API_KEY environment variable.
func NewTavilySearch(apiKey string, opts ...TavilyOption) (*TavilySearch, error) {
if apiKey == "" {
apiKey = os.Getenv("TAVILY_API_KEY")
}
if apiKey == "" {
return nil, fmt.Errorf("TAVILY_API_KEY not set")
}
t := &TavilySearch{
APIKey: apiKey,
BaseURL: "https://api.tavily.com",
SearchDepth: "basic",
}
for _, opt := range opts {
opt(t)
}
return t, nil
}
// Name returns the name of the tool.
func (t *TavilySearch) Name() string {
return "Tavily_Search"
}
// Description returns the description of the tool.
func (t *TavilySearch) Description() string {
return "A search engine optimized for comprehensive, accurate, and trusted results. " +
"Useful for when you need to answer questions about current events. " +
"Input should be a search query."
}
// Call executes the search.
func (t *TavilySearch) Call(ctx context.Context, input string) (string, error) {
reqBody := map[string]any{
"query": input,
"api_key": t.APIKey,
"search_depth": t.SearchDepth,
}
jsonBody, err := json.Marshal(reqBody)
if err != nil {
return "", fmt.Errorf("failed to marshal request body: %w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", t.BaseURL+"/search", bytes.NewBuffer(jsonBody))
if err != nil {
return "", fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("tavily api returned status: %d", resp.StatusCode)
}
var result map[string]any
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return "", fmt.Errorf("failed to decode response: %w", err)
}
// Format the output
var sb strings.Builder
if results, ok := result["results"].([]any); ok {
for _, r := range results {
if item, ok := r.(map[string]any); ok {
title, _ := item["title"].(string)
url, _ := item["url"].(string)
content, _ := item["content"].(string)
sb.WriteString(fmt.Sprintf("Title: %s\nURL: %s\nContent: %s\n\n", title, url, content))
}
}
}
return sb.String(), nil
}
// SearchResult represents a single search result with images
type SearchResult struct {
Text string
Images []string
}
// CallWithImages executes the search and returns both text and images.
func (t *TavilySearch) CallWithImages(ctx context.Context, input string) (*SearchResult, error) {
reqBody := map[string]any{
"query": input,
"api_key": t.APIKey,
"search_depth": t.SearchDepth,
"include_images": true,
}
jsonBody, err := json.Marshal(reqBody)
if err != nil {
return nil, fmt.Errorf("failed to marshal request body: %w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", t.BaseURL+"/search", bytes.NewBuffer(jsonBody))
if err != nil {
return nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return nil, fmt.Errorf("failed to send request: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("tavily api returned status: %d", resp.StatusCode)
}
var result map[string]any
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return nil, fmt.Errorf("failed to decode response: %w", err)
}
searchResult := &SearchResult{
Images: []string{},
}
// Format the text output
var sb strings.Builder
if results, ok := result["results"].([]any); ok {
for _, r := range results {
if item, ok := r.(map[string]any); ok {
title, _ := item["title"].(string)
url, _ := item["url"].(string)
content, _ := item["content"].(string)
sb.WriteString(fmt.Sprintf("Title: %s\nURL: %s\nContent: %s\n\n", title, url, content))
}
}
}
searchResult.Text = sb.String()
// Extract images
if images, ok := result["images"].([]any); ok {
for _, img := range images {
if imgURL, ok := img.(string); ok {
searchResult.Images = append(searchResult.Images, imgURL)
}
}
}
return searchResult, nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/executor_test.go | ptc/executor_test.go | package ptc_test
import (
"context"
"strings"
"testing"
"time"
"github.com/smallnest/langgraphgo/ptc"
"github.com/tmc/langchaingo/tools"
)
// TestModeDirectExecution tests that ModeDirect mode actually executes tools
func TestModeDirectExecution(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "echo",
description: "Echoes input",
response: "echoed: test",
},
}
executor := ptc.NewCodeExecutorWithMode(ptc.LanguagePython, tools, ptc.ModeDirect)
ctx := context.Background()
// Start the executor (Direct mode uses internal server for generic tools)
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Verify tool server URL is available (used internally for generic tools)
serverURL := executor.GetToolServerURL()
if serverURL == "" {
t.Error("Expected non-empty tool server URL in Direct mode (for internal use)")
}
// Test Python code that calls a generic tool
// Generic tools (like echo) are called via internal server
code := `
result = echo("hello")
print(result)
`
result, err := executor.Execute(ctx, code)
if err != nil {
t.Fatalf("Failed to execute code: %v", err)
}
// In Direct mode, generic tools should call through internal server and return actual result
if !strings.Contains(result.Output, "echoed") {
t.Errorf("Expected output to contain 'echoed', got: %s", result.Output)
}
}
// TestModeServerExecution tests that ModeServer mode works
func TestModeServerExecution(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "calculator",
description: "Performs calculations",
response: "42",
},
}
executor := ptc.NewCodeExecutorWithMode(ptc.LanguagePython, tools, ptc.ModeServer)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
serverURL := executor.GetToolServerURL()
if serverURL == "" {
t.Error("Expected non-empty tool server URL in Server mode")
}
// Test Python code that calls tools via HTTP
code := `
result = calculator("2+2")
print(result)
`
result, err := executor.Execute(ctx, code)
if err != nil {
t.Fatalf("Failed to execute code: %v", err)
}
if !strings.Contains(result.Output, "42") {
t.Errorf("Expected output to contain '42', got: %s", result.Output)
}
}
// TestExecutorTimeout tests execution timeout
func TestExecutorTimeout(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test",
description: "Test tool",
response: "ok",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
executor.Timeout = 2 * time.Second
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Code that takes longer than timeout
code := `
import time
time.sleep(10)
print("done")
`
result, err := executor.Execute(ctx, code)
// Timeout may be returned as error or in result
if err == nil && result.Error == nil {
t.Skip("Timeout test skipped - execution completed before timeout")
}
}
// TestGoCodeExecution tests Go code execution
func TestGoCodeExecution(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "greet",
description: "Greets someone",
response: "Hello, World!",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguageGo, tools)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
code := `
result, _ := greet(ctx, "World")
fmt.Println(result)
`
result, err := executor.Execute(ctx, code)
if err != nil {
t.Fatalf("Failed to execute Go code: %v", err)
}
// In Direct mode, generic tools (like "greet") are called via internal server
// and should return the actual tool result
if !strings.Contains(result.Output, "Hello") {
t.Errorf("Expected output to contain 'Hello', got: %s", result.Output)
}
}
// TestMultipleTools tests execution with multiple tools
func TestMultipleTools(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "add",
description: "Adds numbers",
response: "5",
},
MockTool{
name: "multiply",
description: "Multiplies numbers",
response: "10",
},
MockTool{
name: "divide",
description: "Divides numbers",
response: "2",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
code := `
a = add("2+3")
b = multiply("2*5")
c = divide("10/5")
print(f"Results: {a}, {b}, {c}")
`
result, err := executor.Execute(ctx, code)
if err != nil {
t.Fatalf("Failed to execute code: %v", err)
}
output := result.Output
if !strings.Contains(output, "5") || !strings.Contains(output, "10") || !strings.Contains(output, "2") {
t.Errorf("Expected output to contain all results, got: %s", output)
}
}
// TestErrorHandling tests error handling in tool execution
func TestErrorHandling(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test",
description: "Test tool",
response: "ok",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Code with syntax error
code := `
print("unclosed string
`
result, err := executor.Execute(ctx, code)
// Should not return error, but result should contain error info
if err == nil && result.Error == nil {
t.Error("Expected error in result for invalid Python code")
}
}
// TestToolDefinitionsGeneration tests tool definition generation
func TestToolDefinitionsGeneration(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "calculator",
description: "Performs calculations",
response: "result",
},
MockTool{
name: "weather",
description: "Gets weather info",
response: "sunny",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
defs := executor.GetToolDefinitions()
if !strings.Contains(defs, "calculator") {
t.Error("Expected tool definitions to contain 'calculator'")
}
if !strings.Contains(defs, "weather") {
t.Error("Expected tool definitions to contain 'weather'")
}
if !strings.Contains(defs, "Performs calculations") {
t.Error("Expected tool definitions to contain description")
}
}
// TestConcurrentExecution tests concurrent code execution
func TestConcurrentExecution(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test",
description: "Test tool",
response: "ok",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Run multiple executions concurrently
done := make(chan bool, 3)
for i := range 3 {
go func(id int) {
code := `
result = test("input")
print(result)
`
_, err := executor.Execute(ctx, code)
if err != nil {
t.Errorf("Execution %d failed: %v", id, err)
}
done <- true
}(i)
}
// Wait for all executions to complete
for range 3 {
select {
case <-done:
// Success
case <-time.After(30 * time.Second):
t.Fatal("Concurrent execution timed out")
}
}
}
// TestStopWithoutStart tests that Stop works even if Start wasn't called
func TestStopWithoutStart(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test",
description: "Test",
response: "ok",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
ctx := context.Background()
// Should not panic
if err := executor.Stop(ctx); err != nil {
t.Errorf("Stop without Start should not return error: %v", err)
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/ptc_agent_test.go | ptc/ptc_agent_test.go | package ptc_test
import (
"context"
"strings"
"testing"
"github.com/smallnest/langgraphgo/ptc"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/tools"
)
// MockLLM for testing
type MockLLM struct {
response string
callCount int
}
func (m *MockLLM) GenerateContent(ctx context.Context, messages []llms.MessageContent, options ...llms.CallOption) (*llms.ContentResponse, error) {
m.callCount++
return &llms.ContentResponse{
Choices: []*llms.ContentChoice{
{
Content: m.response,
},
},
}, nil
}
func (m *MockLLM) Call(ctx context.Context, prompt string, options ...llms.CallOption) (string, error) {
m.callCount++
return m.response, nil
}
// TestPTCToolNode tests PTCToolNode functionality
func TestPTCToolNode(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "calculator",
description: "Performs calculations",
response: "42",
},
}
node := ptc.NewPTCToolNode(ptc.LanguagePython, tools)
ctx := context.Background()
// Start the tool server
if err := node.Executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer node.Close(ctx)
// Create state with AI message containing code
state := map[string]any{
"messages": []llms.MessageContent{
{
Role: llms.ChatMessageTypeAI,
Parts: []llms.ContentPart{
llms.TextPart("```python\nresult = calculator('2+2')\nprint(result)\n```"),
},
},
},
}
// Invoke the node
newState, err := node.Invoke(ctx, state)
if err != nil {
t.Fatalf("Failed to invoke node: %v", err)
}
// Check that a new message was added
messages := newState.(map[string]any)["messages"].([]llms.MessageContent)
if len(messages) != 2 {
t.Errorf("Expected 2 messages, got %d", len(messages))
}
// Check that the last message contains execution result
lastMsg := messages[len(messages)-1]
if lastMsg.Role != llms.ChatMessageTypeHuman {
t.Errorf("Expected last message to be Human, got %s", lastMsg.Role)
}
}
// TestPTCToolNodeWithGoCode tests PTCToolNode with Go code
func TestPTCToolNodeWithGoCode(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "greet",
description: "Greets someone",
response: "Hello!",
},
}
node := ptc.NewPTCToolNode(ptc.LanguageGo, tools)
ctx := context.Background()
if err := node.Executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer node.Close(ctx)
state := map[string]any{
"messages": []llms.MessageContent{
{
Role: llms.ChatMessageTypeAI,
Parts: []llms.ContentPart{
llms.TextPart("```go\nresult, _ := greet(ctx, \"World\")\nfmt.Println(result)\n```"),
},
},
},
}
newState, err := node.Invoke(ctx, state)
if err != nil {
t.Fatalf("Failed to invoke node: %v", err)
}
messages := newState.(map[string]any)["messages"].([]llms.MessageContent)
if len(messages) != 2 {
t.Errorf("Expected 2 messages, got %d", len(messages))
}
}
// TestPTCToolNodeErrorHandling tests error handling in PTCToolNode
func TestPTCToolNodeErrorHandling(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test",
description: "Test tool",
response: "ok",
},
}
node := ptc.NewPTCToolNode(ptc.LanguagePython, tools)
ctx := context.Background()
if err := node.Executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer node.Close(ctx)
// State with code that has syntax error
state := map[string]any{
"messages": []llms.MessageContent{
{
Role: llms.ChatMessageTypeAI,
Parts: []llms.ContentPart{
llms.TextPart("```python\nprint('unclosed string\n```"),
},
},
},
}
newState, err := node.Invoke(ctx, state)
// Should not return error, but should add error message
if err != nil {
t.Fatalf("Unexpected error: %v", err)
}
messages := newState.(map[string]any)["messages"].([]llms.MessageContent)
lastMsg := messages[len(messages)-1]
lastText := lastMsg.Parts[0].(llms.TextContent).Text
if !strings.Contains(lastText, "Error") && !strings.Contains(lastText, "error") {
t.Error("Expected error message in output")
}
}
// TestPTCToolNodeWithoutCode tests PTCToolNode with plain text (no code blocks)
func TestPTCToolNodeWithoutCode(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test",
description: "Test",
response: "ok",
},
}
node := ptc.NewPTCToolNode(ptc.LanguagePython, tools)
ctx := context.Background()
if err := node.Executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer node.Close(ctx)
// State with plain text (will be treated as code and may execute or error)
state := map[string]any{
"messages": []llms.MessageContent{
{
Role: llms.ChatMessageTypeAI,
Parts: []llms.ContentPart{
llms.TextPart("Just some text without code blocks"),
},
},
},
}
// The node should process this (may succeed or fail depending on execution)
// We just verify it doesn't panic
_, err := node.Invoke(ctx, state)
// Error is acceptable here as plain text may not be valid Python
_ = err
}
// TestPTCAgentConfig tests PTCAgentConfig validation
func TestPTCAgentConfig(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test",
description: "Test",
response: "ok",
},
}
// Test without model
_, err := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
Tools: tools,
})
if err == nil {
t.Error("Expected error when model is not provided")
}
// Test without tools
_, err = ptc.CreatePTCAgent(ptc.PTCAgentConfig{
Model: &MockLLM{response: "test"},
})
if err == nil {
t.Error("Expected error when tools are not provided")
}
}
// TestPTCAgentDefaultConfig tests default configuration
func TestPTCAgentDefaultConfig(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "calculator",
description: "Calculates",
response: "42",
},
}
agent, err := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
Model: &MockLLM{response: "```python\nprint('test')\n```"},
Tools: tools,
})
if err != nil {
t.Fatalf("Failed to create agent with defaults: %v", err)
}
// Agent should be created successfully
if agent == nil {
t.Error("Expected non-nil agent")
}
}
// TestPTCAgentWithCustomConfig tests custom configuration
func TestPTCAgentWithCustomConfig(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test",
description: "Test",
response: "ok",
},
}
agent, err := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
Model: &MockLLM{response: "```go\nfmt.Println(\"test\")\n```"},
Tools: tools,
Language: ptc.LanguageGo,
ExecutionMode: ptc.ModeServer,
SystemPrompt: "You are a helpful assistant",
MaxIterations: 5,
})
if err != nil {
t.Fatalf("Failed to create agent with custom config: %v", err)
}
if agent == nil {
t.Error("Expected non-nil agent")
}
}
// TestSanitizeFunctionName tests function name sanitization
// This is an indirect test through tool definitions
func TestSanitizeFunctionName(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "tool-with-dashes",
description: "Test tool with dashes",
response: "ok",
},
MockTool{
name: "tool.with.dots",
description: "Test tool with dots",
response: "ok",
},
MockTool{
name: "tool with spaces",
description: "Test tool with spaces",
response: "ok",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
defs := executor.GetToolDefinitions()
// Check that sanitized names are present
if !strings.Contains(defs, "tool_with_dashes") {
t.Error("Expected sanitized function name 'tool_with_dashes'")
}
if !strings.Contains(defs, "tool_with_dots") {
t.Error("Expected sanitized function name 'tool_with_dots'")
}
if !strings.Contains(defs, "tool_with_spaces") {
t.Error("Expected sanitized function name 'tool_with_spaces'")
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/tool_server.go | ptc/tool_server.go | package ptc
import (
"context"
"encoding/json"
"fmt"
"net"
"net/http"
"sync"
"time"
"github.com/smallnest/langgraphgo/log"
"github.com/tmc/langchaingo/tools"
)
// ToolServer provides an HTTP API for tool execution
// This allows code in any language to call Go tools via HTTP
type ToolServer struct {
tools map[string]tools.Tool
server *http.Server
port int
mu sync.RWMutex
started bool
}
// ToolRequest represents a tool execution request
type ToolRequest struct {
ToolName string `json:"tool_name"`
Input any `json:"input"`
}
// ToolResponse represents a tool execution response
type ToolResponse struct {
Success bool `json:"success"`
Result string `json:"result"`
Error string `json:"error,omitempty"`
Tool string `json:"tool"`
Input any `json:"input"`
}
// NewToolServer creates a new tool server
func NewToolServer(toolList []tools.Tool) *ToolServer {
toolMap := make(map[string]tools.Tool)
for _, tool := range toolList {
toolMap[tool.Name()] = tool
}
return &ToolServer{
tools: toolMap,
port: 0, // Will be assigned automatically
started: false,
}
}
// Start starts the tool server on an available port
func (ts *ToolServer) Start(ctx context.Context) error {
ts.mu.Lock()
defer ts.mu.Unlock()
if ts.started {
return fmt.Errorf("server already started")
}
// Find an available port
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return fmt.Errorf("failed to find available port: %w", err)
}
ts.port = listener.Addr().(*net.TCPAddr).Port
log.Info("Tool server starting on port %d", ts.port)
mux := http.NewServeMux()
mux.HandleFunc("/tools", ts.handleListTools)
mux.HandleFunc("/call", ts.handleCallTool)
mux.HandleFunc("/health", ts.handleHealth)
ts.server = &http.Server{
Handler: mux,
ReadTimeout: 30 * time.Second,
WriteTimeout: 30 * time.Second,
}
ts.started = true
// Start server in goroutine
go func() {
if err := ts.server.Serve(listener); err != nil && err != http.ErrServerClosed {
log.Error("Tool server error: %v", err)
}
}()
// Wait a bit for server to start
time.Sleep(100 * time.Millisecond)
log.Info("Tool server started successfully on http://127.0.0.1:%d", ts.port)
return nil
}
// Stop stops the tool server
func (ts *ToolServer) Stop(ctx context.Context) error {
ts.mu.Lock()
defer ts.mu.Unlock()
if !ts.started {
return nil
}
ts.started = false
if ts.server != nil {
return ts.server.Shutdown(ctx)
}
return nil
}
// GetPort returns the port the server is listening on
func (ts *ToolServer) GetPort() int {
ts.mu.RLock()
defer ts.mu.RUnlock()
return ts.port
}
// GetBaseURL returns the base URL of the server
func (ts *ToolServer) GetBaseURL() string {
return fmt.Sprintf("http://127.0.0.1:%d", ts.GetPort())
}
// handleHealth handles health check requests
func (ts *ToolServer) handleHealth(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(map[string]any{
"status": "ok",
"tools": len(ts.tools),
}); err != nil {
log.Error("Failed to encode health response: %v", err)
}
}
// handleListTools handles tool listing requests
func (ts *ToolServer) handleListTools(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
ts.mu.RLock()
defer ts.mu.RUnlock()
toolList := make([]map[string]string, 0, len(ts.tools))
for name, tool := range ts.tools {
toolList = append(toolList, map[string]string{
"name": name,
"description": tool.Description(),
})
}
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(map[string]any{
"tools": toolList,
}); err != nil {
log.Error("Failed to encode tools list response: %v", err)
}
}
// handleCallTool handles tool execution requests
func (ts *ToolServer) handleCallTool(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
var req ToolRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
log.Warn("Invalid tool call request: %v", err)
ts.sendErrorResponse(w, "", nil, fmt.Sprintf("Invalid request: %v", err))
return
}
log.Debug("Tool call request: %s", req.ToolName)
ts.mu.RLock()
tool, exists := ts.tools[req.ToolName]
ts.mu.RUnlock()
if !exists {
log.Warn("Tool not found: %s", req.ToolName)
ts.sendErrorResponse(w, req.ToolName, req.Input, fmt.Sprintf("Tool not found: %s", req.ToolName))
return
}
// Convert input to string for tool execution
inputStr := ""
switch v := req.Input.(type) {
case string:
inputStr = v
case map[string]any:
inputBytes, _ := json.Marshal(v)
inputStr = string(inputBytes)
default:
inputBytes, _ := json.Marshal(v)
inputStr = string(inputBytes)
}
log.Debug("Executing tool %s with input length: %d bytes", req.ToolName, len(inputStr))
// Execute tool
ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
defer cancel()
result, err := tool.Call(ctx, inputStr)
if err != nil {
log.Error("Tool %s execution failed: %v", req.ToolName, err)
ts.sendErrorResponse(w, req.ToolName, req.Input, fmt.Sprintf("Tool execution failed: %v", err))
return
}
log.Info("Tool %s executed successfully, result length: %d bytes", req.ToolName, len(result))
ts.sendSuccessResponse(w, req.ToolName, req.Input, result)
}
// sendSuccessResponse sends a successful tool response
func (ts *ToolServer) sendSuccessResponse(w http.ResponseWriter, toolName string, input any, result string) {
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(ToolResponse{
Success: true,
Result: result,
Tool: toolName,
Input: input,
}); err != nil {
log.Error("Failed to encode success response: %v", err)
}
}
// sendErrorResponse sends an error tool response
func (ts *ToolServer) sendErrorResponse(w http.ResponseWriter, toolName string, input any, errorMsg string) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusBadRequest)
if err := json.NewEncoder(w).Encode(ToolResponse{
Success: false,
Error: errorMsg,
Tool: toolName,
Input: input,
}); err != nil {
log.Error("Failed to encode error response: %v", err)
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/executor.go | ptc/executor.go | package ptc
import (
"context"
"encoding/json"
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
"github.com/smallnest/langgraphgo/log"
"github.com/tmc/langchaingo/tools"
)
// ExecutionLanguage defines the programming language for code execution
type ExecutionLanguage string
const (
LanguagePython ExecutionLanguage = "python"
LanguageGo ExecutionLanguage = "go"
)
// ExecutionMode defines how tools are executed in the code
type ExecutionMode string
const (
// ModeServer: All tools are called via HTTP server (alternative)
// - Server URL exposed to user-generated code
// - Tools accessed via HTTP calls in Python/Go code
// - Better isolation (sandboxed)
// - Reliable tool execution
ModeServer ExecutionMode = "server"
// ModeDirect: Hybrid approach for optimal performance (default, recommended)
// - Shell/Python/File tools: Embedded subprocess execution (true local)
// - Generic tools: Internal HTTP server (hidden from user code)
// - Server starts automatically but not exposed to user
// - Best of both worlds: performance + compatibility
ModeDirect ExecutionMode = "direct"
)
// CodeExecutor handles the execution of programmatic tool calling code
type CodeExecutor struct {
Language ExecutionLanguage
Tools []tools.Tool
Timeout time.Duration
WorkDir string
Mode ExecutionMode
toolServer *ToolServer
}
// ExecutionResult contains the result of code execution
type ExecutionResult struct {
Output string
Error error
Stdout string
Stderr string
}
// NewCodeExecutor creates a new code executor for PTC
// Default mode is ModeDirect for simplicity
func NewCodeExecutor(language ExecutionLanguage, toolList []tools.Tool) *CodeExecutor {
return NewCodeExecutorWithMode(language, toolList, ModeDirect)
}
// NewCodeExecutorWithMode creates a new code executor with specified execution mode
func NewCodeExecutorWithMode(language ExecutionLanguage, toolList []tools.Tool, mode ExecutionMode) *CodeExecutor {
executor := &CodeExecutor{
Language: language,
Tools: toolList,
Timeout: 5 * time.Minute,
WorkDir: os.TempDir(),
Mode: mode,
}
// Create tool server for both modes
// In Direct mode: Internal server for generic tools (shell/python/file use embedded execution)
// In Server mode: Exposed server for all tools via HTTP
executor.toolServer = NewToolServer(toolList)
return executor
}
// Start starts the code executor and its tool server
// In both modes, the server is started for tool access:
// - Direct mode: Internal server for generic tools (not exposed in wrappers)
// - Server mode: Server URL exposed to user code
func (ce *CodeExecutor) Start(ctx context.Context) error {
if ce.toolServer != nil {
return ce.toolServer.Start(ctx)
}
return nil
}
// Stop stops the code executor and its tool server
func (ce *CodeExecutor) Stop(ctx context.Context) error {
if ce.toolServer != nil {
return ce.toolServer.Stop(ctx)
}
return nil
}
// GetToolServerURL returns the URL of the tool server
// In Server mode, this URL is exposed to user code
// In Direct mode, returns URL for internal use (not exposed to user)
func (ce *CodeExecutor) GetToolServerURL() string {
if ce.toolServer != nil {
return ce.toolServer.GetBaseURL()
}
return ""
}
// Execute runs the generated code with access to tools
func (ce *CodeExecutor) Execute(ctx context.Context, code string) (*ExecutionResult, error) {
log.Debug("Executing code in %s mode with language %s", ce.Mode, ce.Language)
log.Debug("Code length: %d bytes", len(code))
var result *ExecutionResult
var err error
switch ce.Language {
case LanguagePython:
result, err = ce.executePython(ctx, code)
case LanguageGo:
result, err = ce.executeGo(ctx, code)
default:
err = fmt.Errorf("unsupported language: %s", ce.Language)
log.Error("Unsupported language: %s", ce.Language)
return nil, err
}
if err != nil {
log.Error("Code execution failed: %v", err)
} else {
log.Info("Code execution succeeded, output length: %d bytes", len(result.Output))
}
return result, err
}
// executePython executes Python code with tool bindings
func (ce *CodeExecutor) executePython(ctx context.Context, code string) (*ExecutionResult, error) {
// Create a temporary Python script
scriptPath := filepath.Join(ce.WorkDir, fmt.Sprintf("ptc_script_%d.py", time.Now().UnixNano()))
defer os.Remove(scriptPath)
// Generate Python tool wrapper functions based on execution mode
var toolWrappers string
if ce.Mode == ModeServer {
toolWrappers = ce.generatePythonToolWrappersServer()
} else {
toolWrappers = ce.generatePythonToolWrappersDirect()
}
// Combine tool wrappers and user code
fullScript := fmt.Sprintf(`
import json
import sys
# Tool wrapper functions
%s
# User code
%s
`, toolWrappers, code)
if err := os.WriteFile(scriptPath, []byte(fullScript), 0600); err != nil {
return nil, fmt.Errorf("failed to write script: %w", err)
}
// Execute Python script
execCtx, cancel := context.WithTimeout(ctx, ce.Timeout)
defer cancel()
cmd := exec.CommandContext(execCtx, "python3", scriptPath)
output, err := cmd.CombinedOutput()
result := &ExecutionResult{
Output: string(output),
Stdout: string(output),
}
if err != nil {
result.Error = err
}
return result, nil
}
// executeGo executes Go code with tool bindings
func (ce *CodeExecutor) executeGo(ctx context.Context, code string) (*ExecutionResult, error) {
// Create a temporary Go file
scriptPath := filepath.Join(ce.WorkDir, fmt.Sprintf("ptc_script_%d.go", time.Now().UnixNano()))
defer os.Remove(scriptPath)
// Generate Go tool wrapper functions based on execution mode
var toolWrappers string
if ce.Mode == ModeServer {
toolWrappers = ce.generateGoToolWrappersServer()
} else {
toolWrappers = ce.generateGoToolWrappersDirect()
}
// Combine tool wrappers and user code
fullScript := fmt.Sprintf(`
package main
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"os/exec"
"strings"
)
// Prevent unused import errors
var _ = json.Marshal
var _ = fmt.Println
var _ = strings.Contains
var _ = bytes.NewBuffer
var _ = http.Client{}
var _ = io.ReadAll
// Tool wrapper functions
%s
func main() {
ctx := context.Background()
%s
}
`, toolWrappers, code)
if err := os.WriteFile(scriptPath, []byte(fullScript), 0600); err != nil {
return nil, fmt.Errorf("failed to write script: %w", err)
}
// Execute Go script
execCtx, cancel := context.WithTimeout(ctx, ce.Timeout)
defer cancel()
cmd := exec.CommandContext(execCtx, "go", "run", scriptPath)
output, err := cmd.CombinedOutput()
result := &ExecutionResult{
Output: string(output),
Stdout: string(output),
}
if err != nil {
result.Error = err
}
return result, nil
}
// generatePythonToolWrappersServer creates Python wrapper functions for tools (server mode)
func (ce *CodeExecutor) generatePythonToolWrappersServer() string {
var wrappers []string
serverURL := ce.toolServer.GetBaseURL()
// Create a mapping of tools that can be called via HTTP
toolsMap := make(map[string]string)
for _, tool := range ce.Tools {
toolsMap[tool.Name()] = tool.Description()
}
// Serialize tools map for the wrapper
toolsJSON, _ := json.Marshal(toolsMap)
wrapper := fmt.Sprintf(`
# Available tools: %s
import json
try:
import urllib.request
except ImportError:
import urllib2 as urllib
TOOL_SERVER_URL = "%s"
def call_tool(tool_name, tool_input):
"""Call a tool through the HTTP tool server"""
try:
url = TOOL_SERVER_URL + "/call"
data = json.dumps({
"tool_name": tool_name,
"input": tool_input
}).encode('utf-8')
req = urllib.request.Request(url, data=data, headers={'Content-Type': 'application/json'})
response = urllib.request.urlopen(req)
result = json.loads(response.read().decode('utf-8'))
if result.get("success"):
return result.get("result", "")
else:
return f"Error calling tool {tool_name}: {result.get('error', 'Unknown error')}"
except Exception as e:
return f"Error calling tool {tool_name}: {str(e)}"
`, string(toolsJSON), serverURL)
wrappers = append(wrappers, wrapper)
// Generate individual tool functions
for _, tool := range ce.Tools {
funcWrapper := fmt.Sprintf(`
def %s(input_data):
"""
%s
"""
return call_tool("%s", input_data)
`, sanitizeFunctionName(tool.Name()), tool.Description(), tool.Name())
wrappers = append(wrappers, funcWrapper)
}
return strings.Join(wrappers, "\n")
}
// generatePythonToolWrappersDirect creates Python wrapper functions for tools (direct mode)
// In direct mode, shell/python/file tools are embedded; generic tools use internal server
func (ce *CodeExecutor) generatePythonToolWrappersDirect() string {
var wrappers []string
serverURL := ce.toolServer.GetBaseURL()
// Add common imports and utilities for direct tool execution
wrapper := fmt.Sprintf(`
# Direct tool execution (embedded tools for shell/python/file, internal server for generic tools)
import subprocess
import json
import os
import tempfile
import sys
try:
import urllib.request
except ImportError:
import urllib2 as urllib
INTERNAL_TOOL_SERVER = "%s"
# Helper function to call generic tools via internal server
def _call_generic_tool(tool_name, tool_input):
"""Call a generic tool through the internal tool server"""
try:
url = INTERNAL_TOOL_SERVER + "/call"
data = json.dumps({
"tool_name": tool_name,
"input": tool_input
}).encode('utf-8')
req = urllib.request.Request(url, data=data, headers={'Content-Type': 'application/json'})
response = urllib.request.urlopen(req)
result = json.loads(response.read().decode('utf-8'))
if result.get("success"):
return result.get("result", "")
else:
return f"Error calling tool {tool_name}: {result.get('error', 'Unknown error')}"
except Exception as e:
return f"Error calling tool {tool_name}: {str(e)}"
# Helper function to run shell commands
def _run_shell(code, args=None):
"""Execute shell code directly"""
try:
with tempfile.NamedTemporaryFile(mode='w', suffix='.sh', delete=False) as f:
f.write(code)
script_path = f.name
try:
cmd = ['bash', script_path]
if args:
cmd.extend(args)
result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
return result.stdout + result.stderr
finally:
os.unlink(script_path)
except Exception as e:
return f"Shell execution error: {str(e)}"
# Helper function to run Python code
def _run_python(code, args=None):
"""Execute Python code directly"""
try:
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
f.write(code)
script_path = f.name
try:
python_cmd = sys.executable
cmd = [python_cmd, script_path]
if args:
cmd.extend(args)
result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
return result.stdout + result.stderr
finally:
os.unlink(script_path)
except Exception as e:
return f"Python execution error: {str(e)}"
# Helper function to read files
def _read_file(file_path):
"""Read file content"""
try:
with open(file_path, 'r', encoding='utf-8') as f:
return f.read()
except Exception as e:
return f"File read error: {str(e)}"
# Helper function to write files
def _write_file(file_path, content):
"""Write file content"""
try:
with open(file_path, 'w', encoding='utf-8') as f:
f.write(content)
return f"Successfully wrote to {file_path}"
except Exception as e:
return f"File write error: {str(e)}"
`, serverURL)
wrappers = append(wrappers, wrapper)
// Generate embedded tool functions based on tool name patterns
for _, tool := range ce.Tools {
funcName := sanitizeFunctionName(tool.Name())
toolName := tool.Name()
// Generate appropriate embedded implementation based on tool name
var funcImpl string
// Detect tool type and generate embedded implementation
if strings.Contains(strings.ToLower(toolName), "shell") {
// Shell execution tool
funcImpl = fmt.Sprintf(`
def %s(input_data):
"""
%s
Direct shell execution (embedded)
"""
try:
if isinstance(input_data, str):
# Simple string input - treat as code
return _run_shell(input_data)
elif isinstance(input_data, dict):
# Structured input
code = input_data.get('code', input_data.get('command', ''))
args = input_data.get('args', [])
if isinstance(args, dict):
# Template-style args, inject into code
for key, value in args.items():
code = code.replace('{{.%%s}}' %% key, str(value))
args = []
return _run_shell(code, args)
else:
return _run_shell(str(input_data))
except Exception as e:
return f"Error in %s: {str(e)}"
`, funcName, tool.Description(), tool.Name())
} else if strings.Contains(strings.ToLower(toolName), "python") {
// Python execution tool
funcImpl = fmt.Sprintf(`
def %s(input_data):
"""
%s
Direct Python execution (embedded)
"""
try:
if isinstance(input_data, str):
return _run_python(input_data)
elif isinstance(input_data, dict):
code = input_data.get('code', input_data.get('script', ''))
args = input_data.get('args', [])
if isinstance(args, dict):
for key, value in args.items():
code = code.replace('{{.%%s}}' %% key, str(value))
args = []
return _run_python(code, args)
else:
return _run_python(str(input_data))
except Exception as e:
return f"Error in %s: {str(e)}"
`, funcName, tool.Description(), tool.Name())
} else if strings.Contains(strings.ToLower(toolName), "read") && strings.Contains(strings.ToLower(toolName), "file") {
// File read tool
funcImpl = fmt.Sprintf(`
def %s(input_data):
"""
%s
Direct file reading (embedded)
"""
try:
if isinstance(input_data, str):
return _read_file(input_data)
elif isinstance(input_data, dict):
file_path = input_data.get('filePath', input_data.get('file_path', input_data.get('path', '')))
return _read_file(file_path)
else:
return _read_file(str(input_data))
except Exception as e:
return f"Error in %s: {str(e)}"
`, funcName, tool.Description(), tool.Name())
} else if strings.Contains(strings.ToLower(toolName), "write") && strings.Contains(strings.ToLower(toolName), "file") {
// File write tool
funcImpl = fmt.Sprintf(`
def %s(input_data):
"""
%s
Direct file writing (embedded)
"""
try:
if isinstance(input_data, dict):
file_path = input_data.get('filePath', input_data.get('file_path', input_data.get('path', '')))
content = input_data.get('content', '')
return _write_file(file_path, content)
else:
return "Error: write_file requires dict with 'filePath' and 'content'"
except Exception as e:
return f"Error in %s: {str(e)}"
`, funcName, tool.Description(), tool.Name())
} else {
// Generic tool - call via internal tool server
funcImpl = fmt.Sprintf(`
def %s(input_data):
"""
%s
Generic tool called via internal server.
"""
# Convert input to JSON string if it's a dict
if isinstance(input_data, dict):
input_str = json.dumps(input_data)
else:
input_str = str(input_data)
return _call_generic_tool("%s", input_str)
`, funcName, tool.Description(), tool.Name())
}
wrappers = append(wrappers, funcImpl)
}
return strings.Join(wrappers, "\n")
}
// generateGoToolWrappersServer creates Go wrapper functions for tools (server mode)
func (ce *CodeExecutor) generateGoToolWrappersServer() string {
var wrappers []string
serverURL := ce.toolServer.GetBaseURL()
// Create the call_tool function
wrapper := fmt.Sprintf(`
import (
"bytes"
"io"
"net/http"
"os"
)
const toolServerURL = "%s"
// callTool calls a tool through the HTTP tool server
func callTool(ctx context.Context, toolName string, toolInput any) (string, error) {
requestBody := map[string]any{
"tool_name": toolName,
"input": toolInput,
}
jsonData, err := json.Marshal(requestBody)
if err != nil {
return "", fmt.Errorf("failed to marshal request: %%w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", toolServerURL+"/call", bytes.NewBuffer(jsonData))
if err != nil {
return "", fmt.Errorf("failed to create request: %%w", err)
}
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("failed to call tool: %%w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("failed to read response: %%w", err)
}
var result map[string]any
if err := json.Unmarshal(body, &result); err != nil {
return "", fmt.Errorf("failed to unmarshal response: %%w", err)
}
if success, ok := result["success"].(bool); ok && success {
if resultStr, ok := result["result"].(string); ok {
return resultStr, nil
}
}
errorMsg := "unknown error"
if errStr, ok := result["error"].(string); ok {
errorMsg = errStr
}
return "", fmt.Errorf("tool execution failed: %%s", errorMsg)
}
`, serverURL)
wrappers = append(wrappers, wrapper)
// Generate individual tool functions
for _, tool := range ce.Tools {
funcWrapper := fmt.Sprintf(`
// %s: %s
func %s(ctx context.Context, input string) (string, error) {
return callTool(ctx, "%s", input)
}
`, tool.Name(), tool.Description(), sanitizeFunctionName(tool.Name()), tool.Name())
wrappers = append(wrappers, funcWrapper)
}
return strings.Join(wrappers, "\n")
}
// generateGoToolWrappersDirect creates Go wrapper functions for tools (direct mode)
// In direct mode, shell/python/file tools are embedded; generic tools use internal server
func (ce *CodeExecutor) generateGoToolWrappersDirect() string {
var wrappers []string
serverURL := ce.toolServer.GetBaseURL()
// Add common helper functions for direct tool execution
// (imports are in the main template)
wrapper := fmt.Sprintf(`
// Internal tool server URL for generic tools
const internalToolServer = "%s"
// Helper function to call generic tools via internal server
func callGenericTool(ctx context.Context, toolName string, input string) (string, error) {
requestBody := map[string]any{
"tool_name": toolName,
"input": input,
}
jsonData, err := json.Marshal(requestBody)
if err != nil {
return "", fmt.Errorf("failed to marshal request: %%w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", internalToolServer+"/call", bytes.NewBuffer(jsonData))
if err != nil {
return "", fmt.Errorf("failed to create request: %%w", err)
}
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
return "", fmt.Errorf("failed to call tool: %%w", err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
return "", fmt.Errorf("failed to read response: %%w", err)
}
var result map[string]any
if err := json.Unmarshal(body, &result); err != nil {
return "", fmt.Errorf("failed to unmarshal response: %%w", err)
}
if success, ok := result["success"].(bool); ok && success {
if resultStr, ok := result["result"].(string); ok {
return resultStr, nil
}
}
errorMsg := "unknown error"
if errStr, ok := result["error"].(string); ok {
errorMsg = errStr
}
return "", fmt.Errorf("tool execution failed: %%s", errorMsg)
}
// Helper function to run shell commands
func runShell(ctx context.Context, code string, args []string) (string, error) {
tmpfile, err := os.CreateTemp("", "shell-*.sh")
if err != nil {
return "", err
}
defer os.Remove(tmpfile.Name())
if _, err := tmpfile.Write([]byte(code)); err != nil {
return "", err
}
if err := tmpfile.Close(); err != nil {
return "", err
}
cmd := exec.CommandContext(ctx, "bash", append([]string{tmpfile.Name()}, args...)...)
output, err := cmd.CombinedOutput()
return string(output), err
}
// Helper function to run Python scripts
func runPython(ctx context.Context, code string, args []string) (string, error) {
tmpfile, err := os.CreateTemp("", "python-*.py")
if err != nil {
return "", err
}
defer os.Remove(tmpfile.Name())
if _, err := tmpfile.Write([]byte(code)); err != nil {
return "", err
}
if err := tmpfile.Close(); err != nil {
return "", err
}
pythonCmd := "python3"
if _, err := exec.LookPath("python3"); err != nil {
pythonCmd = "python"
}
cmd := exec.CommandContext(ctx, pythonCmd, append([]string{tmpfile.Name()}, args...)...)
output, err := cmd.CombinedOutput()
return string(output), err
}
// Helper function to read files
func readFile(filePath string) (string, error) {
data, err := os.ReadFile(filePath)
if err != nil {
return "", err
}
return string(data), nil
}
// Helper function to write files
func writeFile(filePath string, content string) (string, error) {
err := os.WriteFile(filePath, []byte(content), 0600)
if err != nil {
return "", err
}
return fmt.Sprintf("Successfully wrote to %%s", filePath), nil
}
`, serverURL)
wrappers = append(wrappers, wrapper)
// Generate embedded tool functions based on tool name patterns
for _, tool := range ce.Tools {
funcName := sanitizeFunctionName(tool.Name())
toolName := tool.Name()
// Generate appropriate embedded implementation based on tool name
var funcImpl string
// Detect tool type and generate embedded implementation
if strings.Contains(strings.ToLower(toolName), "shell") {
// Shell execution tool
funcImpl = fmt.Sprintf(`
// %s: %s (Direct shell execution - embedded)
func %s(ctx context.Context, input string) (string, error) {
// Parse input as JSON if possible
var params map[string]any
if err := json.Unmarshal([]byte(input), ¶ms); err == nil {
// Structured input
code := ""
if codeVal, ok := params["code"]; ok {
code = fmt.Sprintf("%%v", codeVal)
} else if cmdVal, ok := params["command"]; ok {
code = fmt.Sprintf("%%v", cmdVal)
}
args := []string{}
if argsVal, ok := params["args"]; ok {
if argsList, ok := argsVal.([]any); ok {
for _, arg := range argsList {
args = append(args, fmt.Sprintf("%%v", arg))
}
}
}
return runShell(ctx, code, args)
}
// Simple string input - treat as shell code
return runShell(ctx, input, nil)
}`, tool.Name(), tool.Description(), funcName)
} else if strings.Contains(strings.ToLower(toolName), "python") {
// Python execution tool
funcImpl = fmt.Sprintf(`
// %s: %s (Direct Python execution - embedded)
func %s(ctx context.Context, input string) (string, error) {
var params map[string]any
if err := json.Unmarshal([]byte(input), ¶ms); err == nil {
code := ""
if codeVal, ok := params["code"]; ok {
code = fmt.Sprintf("%%v", codeVal)
} else if scriptVal, ok := params["script"]; ok {
code = fmt.Sprintf("%%v", scriptVal)
}
args := []string{}
if argsVal, ok := params["args"]; ok {
if argsList, ok := argsVal.([]any); ok {
for _, arg := range argsList {
args = append(args, fmt.Sprintf("%%v", arg))
}
}
}
return runPython(ctx, code, args)
}
return runPython(ctx, input, nil)
}`, tool.Name(), tool.Description(), funcName)
} else if strings.Contains(strings.ToLower(toolName), "read") && strings.Contains(strings.ToLower(toolName), "file") {
// File read tool
funcImpl = fmt.Sprintf(`
// %s: %s (Direct file reading - embedded)
func %s(ctx context.Context, input string) (string, error) {
var params map[string]any
if err := json.Unmarshal([]byte(input), ¶ms); err == nil {
if filePathVal, ok := params["filePath"]; ok {
return readFile(fmt.Sprintf("%%v", filePathVal))
}
if filePathVal, ok := params["file_path"]; ok {
return readFile(fmt.Sprintf("%%v", filePathVal))
}
if pathVal, ok := params["path"]; ok {
return readFile(fmt.Sprintf("%%v", pathVal))
}
}
return readFile(input)
}`, tool.Name(), tool.Description(), funcName)
} else if strings.Contains(strings.ToLower(toolName), "write") && strings.Contains(strings.ToLower(toolName), "file") {
// File write tool
funcImpl = fmt.Sprintf(`
// %s: %s (Direct file writing - embedded)
func %s(ctx context.Context, input string) (string, error) {
var params map[string]any
if err := json.Unmarshal([]byte(input), ¶ms); err != nil {
return "", fmt.Errorf("write_file requires JSON input with filePath and content")
}
filePath := ""
if val, ok := params["filePath"]; ok {
filePath = fmt.Sprintf("%%v", val)
} else if val, ok := params["file_path"]; ok {
filePath = fmt.Sprintf("%%v", val)
} else if val, ok := params["path"]; ok {
filePath = fmt.Sprintf("%%v", val)
}
content := ""
if val, ok := params["content"]; ok {
content = fmt.Sprintf("%%v", val)
}
if filePath == "" {
return "", fmt.Errorf("filePath is required")
}
return writeFile(filePath, content)
}`, tool.Name(), tool.Description(), funcName)
} else {
// Generic tool - call via internal tool server
funcImpl = fmt.Sprintf(`
// %s: %s (Generic tool called via internal server)
func %s(ctx context.Context, input string) (string, error) {
return callGenericTool(ctx, "%s", input)
}`, tool.Name(), tool.Description(), funcName, tool.Name())
}
wrappers = append(wrappers, funcImpl)
}
return strings.Join(wrappers, "\n")
}
// sanitizeFunctionName converts a tool name to a valid function name
func sanitizeFunctionName(name string) string {
// Replace invalid characters with underscores
name = strings.ReplaceAll(name, "-", "_")
name = strings.ReplaceAll(name, " ", "_")
name = strings.ReplaceAll(name, ".", "_")
// Ensure it starts with a letter
if len(name) > 0 && name[0] >= '0' && name[0] <= '9' {
name = "tool_" + name
}
return name
}
// GetToolDefinitions returns tool definitions for LLM prompting
func (ce *CodeExecutor) GetToolDefinitions() string {
var defs []string
defs = append(defs, "# Available Tools\n")
defs = append(defs, "You have access to the following tools that you can call in your code:\n")
for _, tool := range ce.Tools {
def := fmt.Sprintf("\n## %s\n", tool.Name())
def += fmt.Sprintf("Description: %s\n", tool.Description())
def += fmt.Sprintf("Usage: %s(input_string)\n", sanitizeFunctionName(tool.Name()))
defs = append(defs, def)
}
return strings.Join(defs, "")
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/ptc_agent.go | ptc/ptc_agent.go | package ptc
import (
"context"
"fmt"
"strings"
"github.com/smallnest/langgraphgo/graph"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/tools"
)
// PTCAgentConfig configures a PTC agent
type PTCAgentConfig struct {
// Model is the LLM to use
Model llms.Model
// Tools are the available tools
Tools []tools.Tool
// Language is the execution language for code
Language ExecutionLanguage
// ExecutionMode determines how tools are executed (default: ModeDirect)
// - ModeDirect: Tools are executed directly via subprocess (default)
// - ModeServer: Tools are executed via HTTP server (alternative)
ExecutionMode ExecutionMode
// SystemPrompt is the system prompt for the agent
SystemPrompt string
// MaxIterations is the maximum number of iterations (default: 10)
MaxIterations int
}
// CreatePTCAgent creates a new agent that uses programmatic tool calling
// This agent generates code to call tools programmatically rather than
// using traditional tool calling with round-trips
func CreatePTCAgent(config PTCAgentConfig) (*graph.Runnable, error) {
if config.Model == nil {
return nil, fmt.Errorf("model is required")
}
if len(config.Tools) == 0 {
return nil, fmt.Errorf("at least one tool is required")
}
if config.Language == "" {
config.Language = LanguagePython // Default to Python
}
if config.ExecutionMode == "" {
config.ExecutionMode = ModeDirect // Default to direct mode
}
if config.MaxIterations == 0 {
config.MaxIterations = 20
}
// Create PTC tool node with execution mode
ptcNode := NewPTCToolNodeWithMode(config.Language, config.Tools, config.ExecutionMode)
// Start the tool server
if err := ptcNode.Executor.Start(context.Background()); err != nil {
return nil, fmt.Errorf("failed to start tool server: %w", err)
}
// Build system prompt with tool definitions
systemPrompt := BuildSystemPrompt(config.SystemPrompt, config.Language, ptcNode.Executor)
// Create the graph
workflow := graph.NewStateGraph[map[string]any]()
// Define the state schema
schema := graph.NewMapSchema()
schema.RegisterReducer("messages", graph.AddMessages)
workflow.SetSchema(schema)
// Add agent node
workflow.AddNode("agent", "LLM agent that generates code for tool calling", func(ctx context.Context, state map[string]any) (map[string]any, error) {
return agentNode(ctx, state, config.Model, systemPrompt, config.MaxIterations)
})
// Add PTC execution node
workflow.AddNode("execute_code", "Executes generated code with tool access", func(ctx context.Context, state map[string]any) (map[string]any, error) {
result, err := ptcNode.Invoke(ctx, state)
if err != nil {
return nil, err
}
if resultMap, ok := result.(map[string]any); ok {
return resultMap, nil
}
return state, nil
})
// Set entry point
workflow.SetEntryPoint("agent")
// Add conditional routing
workflow.AddConditionalEdge("agent", func(ctx context.Context, state map[string]any) string {
messages := state["messages"].([]llms.MessageContent)
if len(messages) == 0 {
return graph.END
}
lastMsg := messages[len(messages)-1]
// Check if the message contains code to execute
if lastMsg.Role == llms.ChatMessageTypeAI && ContainsCode(lastMsg) {
return "execute_code"
}
// Otherwise, we're done
return graph.END
})
// Add edge from execute_code back to agent
workflow.AddEdge("execute_code", "agent")
// Compile the graph
app, err := workflow.Compile()
if err != nil {
return nil, fmt.Errorf("failed to compile graph: %w", err)
}
return app, nil
}
// agentNode is the main agent logic node
func agentNode(ctx context.Context, state map[string]any, model llms.Model, systemPrompt string, maxIterations int) (map[string]any, error) {
messages := state["messages"].([]llms.MessageContent)
// Check iteration count
iterationCount := 0
if count, ok := state["iteration_count"].(int); ok {
iterationCount = count
}
if iterationCount >= maxIterations {
// Max iterations reached, return final message
finalMsg := llms.MessageContent{
Role: llms.ChatMessageTypeAI,
Parts: []llms.ContentPart{
llms.TextPart("Maximum iterations reached. Please try a simpler query."),
},
}
state["messages"] = []llms.MessageContent{finalMsg}
return state, nil
}
// Increment iteration count
state["iteration_count"] = iterationCount + 1
// Prepend system message if not already present
if len(messages) == 0 || messages[0].Role != llms.ChatMessageTypeSystem {
messages = append([]llms.MessageContent{
{
Role: llms.ChatMessageTypeSystem,
Parts: []llms.ContentPart{
llms.TextPart(systemPrompt),
},
},
}, messages...)
}
// Call the model
resp, err := model.GenerateContent(ctx, messages)
if err != nil {
return nil, fmt.Errorf("failed to generate content: %w", err)
}
// Extract response
var responseContent []llms.ContentPart
for _, choice := range resp.Choices {
if choice.Content != "" {
responseContent = append(responseContent, llms.TextPart(choice.Content))
}
}
if len(responseContent) == 0 {
return nil, fmt.Errorf("empty response from model")
}
// Add AI response to messages
aiMsg := llms.MessageContent{
Role: llms.ChatMessageTypeAI,
Parts: responseContent,
}
state["messages"] = append(state["messages"].([]llms.MessageContent), aiMsg)
return state, nil
}
// buildSystemPrompt builds the system prompt with tool definitions
// BuildSystemPrompt builds the system prompt with tool definitions
func BuildSystemPrompt(userPrompt string, language ExecutionLanguage, executor *CodeExecutor) string {
toolDefs := executor.GetToolDefinitions()
langName := "Python"
if language == LanguageGo {
langName = "Go"
}
langNameLower := strings.ToLower(langName)
basePrompt := fmt.Sprintf(`You are an AI assistant that can write %s code to solve problems using available tools.
When you need to use tools to answer a question, write %s code that calls the tools programmatically.
The code you write will be executed in a secure environment with access to all the tools.
%s
IMPORTANT GUIDELINES:
1. Write complete, executable %s code
2. Use the tool functions provided above to call tools
3. Process and filter data programmatically to extract only relevant information
4. Print the final result to stdout
5. Handle errors gracefully
6. When you have the final answer, respond with just the answer (no code)
Format your code in markdown code blocks:
`+"```"+langNameLower+`
# Your code here
`+"```", langName, langName, toolDefs, langName)
if userPrompt != "" {
return userPrompt + "\n\n" + basePrompt
}
return basePrompt
}
// containsCode checks if a message contains code to execute
// ContainsCode checks if a message contains code to execute
func ContainsCode(msg llms.MessageContent) bool {
for _, part := range msg.Parts {
if textPart, ok := part.(llms.TextContent); ok {
text := textPart.Text
textLower := strings.ToLower(text)
if (strings.Contains(textLower, "```python") || strings.Contains(textLower, "```go")) && strings.Count(textLower, "```") >= 2 {
return true
}
}
}
return false
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/ptc_agent_additional_test.go | ptc/ptc_agent_additional_test.go | package ptc
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/tools"
)
// MockTool for testing
type MockTool struct {
name string
description string
// If returnError is true, the tool will return an error
returnError bool
}
func (t *MockTool) Name() string {
return t.name
}
func (t *MockTool) Description() string {
return t.description
}
func (t *MockTool) Call(ctx context.Context, input string) (string, error) {
if t.returnError {
return "", fmt.Errorf("tool execution failed")
}
return fmt.Sprintf("Result for %s", input), nil
}
// MockLLM for testing
type MockLLM struct {
response string
}
func (m *MockLLM) GenerateContent(ctx context.Context, messages []llms.MessageContent, options ...llms.CallOption) (*llms.ContentResponse, error) {
return &llms.ContentResponse{
Choices: []*llms.ContentChoice{
{
Content: m.response,
},
},
}, nil
}
func (m *MockLLM) Call(ctx context.Context, prompt string, options ...llms.CallOption) (string, error) {
return m.response, nil
}
func TestContainsCode(t *testing.T) {
tests := []struct {
name string
message llms.MessageContent
expected bool
}{
{
name: "Python code block",
message: llms.MessageContent{
Parts: []llms.ContentPart{
llms.TextPart("Here is some python code:\n```python\nprint('Hello, world!')\n```"),
},
},
expected: true,
},
{
name: "Go code block",
message: llms.MessageContent{
Parts: []llms.ContentPart{
llms.TextPart("Here is some go code:\n```go\nfmt.Println(\"Hello, world!\")\n```"),
},
},
expected: true,
},
{
name: "No code block",
message: llms.MessageContent{
Parts: []llms.ContentPart{
llms.TextPart("This is a regular message."),
},
},
expected: false,
},
{
name: "Partial code block",
message: llms.MessageContent{
Parts: []llms.ContentPart{
llms.TextPart("This is a partial code block: ```py"),
},
},
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assert.Equal(t, tt.expected, ContainsCode(tt.message))
})
}
}
func TestBuildSystemPrompt(t *testing.T) {
executor := &CodeExecutor{
Tools: []tools.Tool{
&MockTool{name: "test_tool", description: "A test tool"},
},
}
tests := []struct {
name string
userPrompt string
language ExecutionLanguage
expected string
}{
{
name: "Python with user prompt",
userPrompt: "You are a helpful assistant.",
language: LanguagePython,
expected: "```python",
},
{
name: "Go with no user prompt",
userPrompt: "",
language: LanguageGo,
expected: "```go",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
prompt := BuildSystemPrompt(tt.userPrompt, tt.language, executor)
if !strings.Contains(prompt, tt.expected) {
t.Errorf("Expected %s code block marker for language %s", tt.expected, tt.language)
}
})
}
}
func TestAgentNodeMaxIterations(t *testing.T) {
mockLLM := &MockLLM{response: "This is a response."}
maxIterations := 3
initialState := map[string]any{
"messages": []llms.MessageContent{},
"iteration_count": maxIterations,
}
_, err := agentNode(context.Background(), initialState, mockLLM, "system prompt", maxIterations)
require.NoError(t, err)
finalState := initialState
messages := finalState["messages"].([]llms.MessageContent)
lastMessage := messages[len(messages)-1]
lastPart := lastMessage.Parts[0].(llms.TextContent)
assert.Contains(t, lastPart.Text, "Maximum iterations reached")
}
func TestCreatePTCAgent(t *testing.T) {
mockLLM := &MockLLM{response: "This is a response."}
tool := &MockTool{name: "test_tool"}
// Create a mock server
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Write([]byte(`{"result": "mock server response"}`))
}))
defer server.Close()
config := PTCAgentConfig{
Model: mockLLM,
Tools: []tools.Tool{tool},
Language: LanguagePython,
ExecutionMode: ModeServer, // Use server mode for testing
}
// The executor in CreatePTCAgent starts a server, which we can't easily do in a test.
// So we can't fully test CreatePTCAgent here, but we can check the config validation.
// Test without model
config.Model = nil
_, err := CreatePTCAgent(config)
assert.Error(t, err)
config.Model = mockLLM
// Test without tools
config.Tools = []tools.Tool{}
_, err = CreatePTCAgent(config)
assert.Error(t, err)
config.Tools = []tools.Tool{tool}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/doc.go | ptc/doc.go | // Package ptc (Programmatic Tool Calling) provides advanced tool execution capabilities for LangGraph Go agents.
//
// This package implements a novel approach to tool calling where agents generate code to use tools
// programmatically, rather than using traditional function calling APIs. This enables more flexible,
// composable, and powerful tool usage patterns.
//
// # Core Concepts
//
// ## Programmatic Tool Calling (PTC)
// Instead of the agent making individual tool calls through a structured API, PTC agents generate
// code that imports and uses tools directly. This approach offers several advantages:
//
// - More natural tool composition in code
// - Ability to use control flow (loops, conditionals) with tools
// - Easier debugging and inspection
// - No need for complex tool schemas
// - Better performance for multi-tool operations
//
// ## Supported Languages
//
// The package currently supports:
//
// - Python (LanguagePython): Full Python runtime with standard library
// - JavaScript (LanguageJavaScript): Node.js runtime execution
// - Shell (LanguageShell): Bash shell command execution
//
// # Key Components
//
// ## PTCAgent
// The main agent implementation that generates and executes tool-calling code:
//
// import (
// "github.com/smallnest/langgraphgo/ptc"
// "github.com/tmc/langchaingo/llms"
// "github.com/tmc/langchaingo/tools"
// )
//
// // Create agent with Python execution
// agent, err := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
// Model: llm,
// Tools: []tools.Tool{calculator, weatherTool},
// Language: ptc.LanguagePython,
// MaxIterations: 10,
// })
//
// ## Execution Modes
//
// Two execution modes are available:
//
// - ModeDirect: Execute code in subprocess (default)
// - ModeServer: Execute code via HTTP server (for sandboxing)
//
// ## PTCToolNode
// A graph node that handles the execution of generated code:
//
// node := ptc.NewPTCToolNodeWithMode(
// ptc.LanguagePython,
// toolList,
// ptc.ModeDirect,
// )
//
// # Example Usage
//
// ## Basic Agent
//
// package main
//
// import (
// "context"
// "fmt"
//
// "github.com/smallnest/langgraphgo/ptc"
// "github.com/tmc/langchaingo/llms/openai"
// "github.com/tmc/langchaingo/tools"
// )
//
// func main() {
// // Initialize LLM
// llm, _ := openai.New()
//
// // Create a calculator tool
// calculator := &tools.CalculatorTool{}
//
// // Create PTC agent
// agent, err := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
// Model: llm,
// Tools: []tools.Tool{calculator},
// Language: ptc.LanguagePython,
// })
// if err != nil {
// panic(err)
// }
//
// // Execute agent
// ctx := context.Background()
// result, err := agent.Invoke(ctx, map[string]any{
// "messages": []llms.MessageContent{
// {
// Role: llms.ChatMessageTypeHuman,
// Parts: []llms.ContentPart{
// llms.TextPart("What is 123 * 456?"),
// },
// },
// },
// })
//
// if err != nil {
// panic(err)
// }
//
// fmt.Printf("Result: %v\n", result)
// }
//
// ## Custom Tools
//
// type WeatherTool struct{}
//
// func (t *WeatherTool) Name() string { return "get_weather" }
// func (t *WeatherTool) Description() string {
// return "Get current weather for a city"
// }
//
// func (t *WeatherTool) Call(ctx context.Context, input string) (string, error) {
// // Implementation
// return "The weather in London is 15°C and sunny", nil
// }
//
// // Use with PTC agent
// weather := &WeatherTool{}
// agent, err := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
// Model: llm,
// Tools: []tools.Tool{weather},
// Language: ptc.LanguageJavaScript,
// })
//
// ## Server Mode Execution
//
// // Start tool server for sandboxed execution
// server := ptc.NewToolServer(8080)
// go server.Start()
// defer server.Stop()
//
// agent, err := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
// Model: llm,
// Tools: toolList,
// Language: ptc.LanguagePython,
// ExecutionMode: ptc.ModeServer,
// ServerURL: "http://localhost:8080",
// })
//
// # Advanced Features
//
// ## Code Generation
// The agent generates code like this:
//
// ```python
// import json
//
// # Tool imports are automatically added
// from tools import calculator, weather
//
// # User query: "Calculate 15% tip on $100 bill"
// bill_amount = 100
// tip_rate = 0.15
// tip = calculator.multiply(bill_amount, tip_rate)
//
// result = {
// "bill_amount": bill_amount,
// "tip_rate": tip_rate,
// "tip_amount": tip,
// "total": bill_amount + tip
// }
//
// print(json.dumps(result))
// ```
//
// ## Error Handling
// The system includes comprehensive error handling:
//
// - Syntax errors in generated code
// - Runtime errors during execution
// - Tool execution failures
// - Timeout protection
// - Resource usage limits
//
// # Security Considerations
//
// - Use server mode for isolation
// - Set appropriate timeouts
// - Monitor resource usage
// - Validate tool inputs/outputs
// - Consider sandboxing for untrusted code
//
// # Performance
//
// - Code execution is generally faster than multiple tool calls
// - Consider caching for repeated operations
// - Monitor execution time for long-running operations
// - Use streaming for real-time feedback
//
// # Integration with LangGraph
//
// The PTC agent integrates seamlessly with LangGraph:
//
// g := graph.NewStateGraph()
//
// // Add PTC node
// ptcNode := ptc.NewPTCToolNode(ptc.LanguagePython, tools)
// g.AddNode("tools", ptcNode.Invoke)
//
// // Add LLM node for reasoning
// g.AddNode("reason", llmNode)
//
// // Define execution flow
// g.SetEntry("reason")
// g.AddEdge("reason", "tools")
// g.AddConditionalEdge("tools", shouldContinue, "continue", "end")
//
// // Compile and run
// runnable := g.Compile()
// result, _ := runnable.Invoke(ctx, initialState)
//
// # Best Practices
//
// 1. Choose appropriate execution language based on your tools
// 2. Use ModeServer for production environments
// 3. Set reasonable iteration limits
// 4. Provide clear tool descriptions
// 5. Handle errors gracefully in your tools
// 6. Test with various input patterns
// 7. Monitor execution for resource usage
// 8. Use timeouts for long-running operations
//
// # Limitations
//
// - Requires runtime environment for chosen language
// - Generated code might have bugs
// - Debugging generated code can be challenging
// - Security risks with unrestricted code execution
package ptc
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/examples_test.go | ptc/examples_test.go | package ptc_test
import (
"context"
"encoding/json"
"fmt"
"testing"
"github.com/smallnest/langgraphgo/ptc"
"github.com/tmc/langchaingo/tools"
)
// MockTool for testing
type MockTool struct {
name string
description string
response string
}
func (t MockTool) Name() string {
return t.name
}
func (t MockTool) Description() string {
return t.description
}
func (t MockTool) Call(ctx context.Context, input string) (string, error) {
return t.response, nil
}
func TestCodeExecutor(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "calculator",
description: "Performs calculations",
response: "42",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
ctx := context.Background()
// Start the tool server
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Test Python code execution
code := `
result = 2 + 2
print(f"Result: {result}")
`
result, err := executor.Execute(ctx, code)
if err != nil {
t.Fatalf("Failed to execute code: %v", err)
}
if result.Output == "" {
t.Error("Expected non-empty output")
}
}
func TestToolServer(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "test_tool",
description: "A test tool",
response: "test response",
},
}
server := ptc.NewToolServer(tools)
ctx := context.Background()
if err := server.Start(ctx); err != nil {
t.Fatalf("Failed to start server: %v", err)
}
defer server.Stop(ctx)
// Test that server is running
port := server.GetPort()
if port == 0 {
t.Error("Expected non-zero port")
}
baseURL := server.GetBaseURL()
if baseURL == "" {
t.Error("Expected non-empty base URL")
}
}
func ExampleCreatePTCAgent() {
// This example shows how to create a PTC agent
// Note: This requires a real LLM and won't run in tests
// Create tools
_ = []tools.Tool{
MockTool{
name: "calculator",
description: "Performs arithmetic calculations",
response: "42",
},
}
// In real usage, you would use:
// model, _ := openai.New()
// agent, _ := ptc.CreatePTCAgent(ptc.PTCAgentConfig{
// Model: model,
// Tools: tools,
// Language: ptc.LanguagePython,
// MaxIterations: 10,
// })
// result, _ := agent.Invoke(context.Background(), initialState)
fmt.Println("PTC Agent created successfully")
// Output: PTC Agent created successfully
}
func ExampleCodeExecutor_Execute() {
tools := []tools.Tool{
MockTool{
name: "get_data",
description: "Gets some data",
response: `{"value": 100}`,
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
ctx := context.Background()
executor.Start(ctx)
defer executor.Stop(ctx)
code := `
# Process data
data = {"numbers": [1, 2, 3, 4, 5]}
total = sum(data["numbers"])
print(f"Total: {total}")
`
result, err := executor.Execute(ctx, code)
if err != nil {
fmt.Printf("Error: %v\n", err)
return
}
fmt.Printf("Executed successfully: %t\n", result.Output != "")
// Output: Executed successfully: true
}
func TestToolDefinitions(t *testing.T) {
tools := []tools.Tool{
MockTool{
name: "tool1",
description: "Description 1",
response: "response1",
},
MockTool{
name: "tool2",
description: "Description 2",
response: "response2",
},
}
executor := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
defs := executor.GetToolDefinitions()
if defs == "" {
t.Error("Expected non-empty tool definitions")
}
// Check that both tools are mentioned
if !contains(defs, "tool1") || !contains(defs, "tool2") {
t.Error("Tool definitions should mention all tools")
}
}
func TestExecutionResult(t *testing.T) {
result := &ptc.ExecutionResult{
Output: "test output",
Stdout: "stdout content",
Stderr: "stderr content",
}
if result.Output != "test output" {
t.Errorf("Expected 'test output', got '%s'", result.Output)
}
}
func contains(s, substr string) bool {
return len(s) >= len(substr) && findSubstring(s, substr)
}
func findSubstring(s, substr string) bool {
for i := 0; i <= len(s)-len(substr); i++ {
if s[i:i+len(substr)] == substr {
return true
}
}
return false
}
// Example of using PTC with different execution languages
func ExampleExecutionLanguage() {
tools := []tools.Tool{
MockTool{name: "tool1", description: "A tool", response: "response"},
}
// Python executor
pythonExec := ptc.NewCodeExecutor(ptc.LanguagePython, tools)
fmt.Printf("Python executor created: %v\n", pythonExec != nil)
// Go executor
goExec := ptc.NewCodeExecutor(ptc.LanguageGo, tools)
fmt.Printf("Go executor created: %v\n", goExec != nil)
// Output:
// Python executor created: true
// Go executor created: true
}
// Example of tool server request/response format
func ExampleToolServer_requestFormat() {
request := map[string]any{
"tool_name": "calculator",
"input": "2 + 2",
}
requestJSON, _ := json.MarshalIndent(request, "", " ")
fmt.Printf("Tool Request:\n%s\n", string(requestJSON))
response := map[string]any{
"success": true,
"result": "4",
"tool": "calculator",
"input": "2 + 2",
}
responseJSON, _ := json.MarshalIndent(response, "", " ")
fmt.Printf("\nTool Response:\n%s\n", string(responseJSON))
// Output:
// Tool Request:
// {
// "input": "2 + 2",
// "tool_name": "calculator"
// }
//
// Tool Response:
// {
// "input": "2 + 2",
// "result": "4",
// "success": true,
// "tool": "calculator"
// }
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/test_utils.go | ptc/test_utils.go | package ptc
import (
"context"
)
// mockTool is a simple mock tool for testing
// Defined as lowercase to make it package-private but accessible to tests
type mockTool struct {
name string
description string
response string
}
func (t mockTool) Name() string {
return t.name
}
func (t mockTool) Description() string {
return t.description
}
func (t mockTool) Call(ctx context.Context, input string) (string, error) {
return t.response, nil
}
// newMockTool creates a new mock tool for testing
func newMockTool(name, description, response string) mockTool {
return mockTool{
name: name,
description: description,
response: response,
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/ptc_node.go | ptc/ptc_node.go | package ptc
import (
"context"
"encoding/json"
"fmt"
"github.com/tmc/langchaingo/llms"
"github.com/tmc/langchaingo/tools"
)
// PTCToolNode is a graph node that handles programmatic tool calling
// It receives code from the LLM and executes it with tool access
type PTCToolNode struct {
Executor *CodeExecutor
}
// NewPTCToolNode creates a new PTC tool node with default execution mode (direct)
func NewPTCToolNode(language ExecutionLanguage, toolList []tools.Tool) *PTCToolNode {
return NewPTCToolNodeWithMode(language, toolList, ModeDirect)
}
// NewPTCToolNodeWithMode creates a new PTC tool node with specified execution mode
func NewPTCToolNodeWithMode(language ExecutionLanguage, toolList []tools.Tool, mode ExecutionMode) *PTCToolNode {
return &PTCToolNode{
Executor: NewCodeExecutorWithMode(language, toolList, mode),
}
}
// Invoke executes the PTC node logic
func (node *PTCToolNode) Invoke(ctx context.Context, state any) (any, error) {
mState, ok := state.(map[string]any)
if !ok {
return nil, fmt.Errorf("state must be a map[string]any")
}
// Extract messages from state
messagesInterface, ok := mState["messages"]
if !ok {
return nil, fmt.Errorf("messages not found in state")
}
messages, ok := messagesInterface.([]llms.MessageContent)
if !ok {
return nil, fmt.Errorf("messages must be []llms.MessageContent")
}
if len(messages) == 0 {
return nil, fmt.Errorf("no messages in state")
}
// Get the last message from the AI
lastMsg := messages[len(messages)-1]
if lastMsg.Role != llms.ChatMessageTypeAI {
return nil, fmt.Errorf("last message must be from AI")
}
// Extract code from the message
code, err := extractCodeFromMessage(lastMsg)
if err != nil {
return nil, fmt.Errorf("failed to extract code: %w", err)
}
// Note: Tool server is already started in CreatePTCAgent, no need to start again
// Execute the code
result, err := node.Executor.Execute(ctx, code)
if err != nil {
// Create error message as system message
errorMsg := llms.MessageContent{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart(fmt.Sprintf("[Code Execution Error]\n%v\n\nOutput:\n%s", err, result.Output)),
},
}
mState["messages"] = append(messages, errorMsg)
return mState, nil
}
// Create success message with execution results as human message
successMsg := llms.MessageContent{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart(fmt.Sprintf("[Code Execution Result]\n%s", result.Output)),
},
}
mState["messages"] = append(messages, successMsg)
return mState, nil
}
// extractCodeFromMessage extracts code from an AI message
// Supports multiple formats:
// 1. Code in markdown code blocks (```language\ncode\n```)
// 2. Plain text code
// 3. JSON with "code" field
func extractCodeFromMessage(msg llms.MessageContent) (string, error) {
for _, part := range msg.Parts {
switch p := part.(type) {
case llms.TextContent:
code := p.Text
// Try to extract code from markdown code blocks
if extracted := extractFromCodeBlock(code); extracted != "" {
return extracted, nil
}
// Try to parse as JSON
var jsonData map[string]any
if err := json.Unmarshal([]byte(code), &jsonData); err == nil {
if codeField, ok := jsonData["code"].(string); ok {
return codeField, nil
}
}
// Return as is
return code, nil
}
}
return "", fmt.Errorf("no code found in message")
}
// extractFromCodeBlock extracts code from markdown code blocks
func extractFromCodeBlock(text string) string {
// Look for code blocks: ```language\ncode\n```
start := -1
end := -1
// Find first ```
for i := 0; i < len(text)-2; i++ {
if text[i:i+3] == "```" {
if start == -1 {
// Find the end of the first line (language specifier)
lineEnd := i + 3
for lineEnd < len(text) && text[lineEnd] != '\n' {
lineEnd++
}
if lineEnd < len(text) {
start = lineEnd + 1
}
} else {
end = i
break
}
}
}
if start != -1 && end != -1 && end > start {
return text[start:end]
}
return ""
}
// Close stops the tool server
func (node *PTCToolNode) Close(ctx context.Context) error {
if node.Executor != nil {
return node.Executor.Stop(ctx)
}
return nil
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/logger_test.go | ptc/logger_test.go | package ptc
import (
"bytes"
"context"
"strings"
"testing"
"github.com/smallnest/langgraphgo/log"
"github.com/tmc/langchaingo/tools"
)
// TestLogger tests the logging functionality using package-level logger
func TestLogger(t *testing.T) {
// Save original logger
originalLogger := log.GetDefaultLogger()
defer log.SetDefaultLogger(originalLogger)
// Create a buffer to capture log output
var buf bytes.Buffer
logger := log.NewCustomLogger(&buf, log.LogLevelDebug)
log.SetDefaultLogger(logger)
toolList := []tools.Tool{
newMockTool("test", "Test tool", "ok"),
}
executor := NewCodeExecutor(LanguagePython, toolList)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
code := `
result = test("hello")
print(result)
`
_, err := executor.Execute(ctx, code)
if err != nil {
t.Fatalf("Failed to execute code: %v", err)
}
// Check that logs were written
logOutput := buf.String()
if logOutput == "" {
t.Error("Expected log output, got none")
}
// Check for expected log entries
expectedLogs := []string{
"Tool server starting on port",
"Tool server started successfully",
"Executing code in",
"Code execution succeeded",
}
for _, expected := range expectedLogs {
if !strings.Contains(logOutput, expected) {
t.Errorf("Expected log to contain '%s', got: %s", expected, logOutput)
}
}
}
// TestLogLevels tests different log levels
func TestLogLevels(t *testing.T) {
tests := []struct {
name string
level log.LogLevel
shouldContain []string
shouldNotContain []string
}{
{
name: "Debug level",
level: log.LogLevelDebug,
shouldContain: []string{"[DEBUG]", "[INFO]", "[WARN]", "[ERROR]"},
},
{
name: "Info level",
level: log.LogLevelInfo,
shouldContain: []string{"[INFO]", "[WARN]", "[ERROR]"},
shouldNotContain: []string{"[DEBUG]"},
},
{
name: "Error level",
level: log.LogLevelError,
shouldContain: []string{"[ERROR]"},
shouldNotContain: []string{"[DEBUG]", "[INFO]", "[WARN]"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var buf bytes.Buffer
logger := log.NewCustomLogger(&buf, tt.level)
// Log messages at all levels
logger.Debug("debug message")
logger.Info("info message")
logger.Warn("warn message")
logger.Error("error message")
output := buf.String()
for _, expected := range tt.shouldContain {
if !strings.Contains(output, expected) {
t.Errorf("Expected output to contain '%s'", expected)
}
}
for _, unexpected := range tt.shouldNotContain {
if strings.Contains(output, unexpected) {
t.Errorf("Expected output NOT to contain '%s'", unexpected)
}
}
})
}
}
// TestNoOpLogger tests that NoOpLogger doesn't produce any output
func TestNoOpLogger(t *testing.T) {
logger := &log.NoOpLogger{}
// These should not panic or produce output
logger.Debug("test")
logger.Info("test")
logger.Warn("test")
logger.Error("test")
}
// TestLogLevelString tests LogLevel.String()
func TestLogLevelString(t *testing.T) {
tests := []struct {
level log.LogLevel
expected string
}{
{log.LogLevelDebug, "DEBUG"},
{log.LogLevelInfo, "INFO"},
{log.LogLevelWarn, "WARN"},
{log.LogLevelError, "ERROR"},
{log.LogLevelNone, "NONE"},
{log.LogLevel(999), "UNKNOWN(999)"},
}
for _, tt := range tests {
if got := tt.level.String(); got != tt.expected {
t.Errorf("LogLevel(%d).String() = %s, want %s", tt.level, got, tt.expected)
}
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/ptc/edge_cases_test.go | ptc/edge_cases_test.go | package ptc
import (
"context"
"strings"
"testing"
"time"
"github.com/smallnest/langgraphgo/log"
"github.com/tmc/langchaingo/tools"
)
// TestPackageLevelLogging tests using package-level logging functions
func TestPackageLevelLogging(t *testing.T) {
// Save original logger
originalLogger := log.GetDefaultLogger()
defer log.SetDefaultLogger(originalLogger)
// Enable logging for this test
log.SetLogLevel(log.LogLevelInfo)
toolList := []tools.Tool{
newMockTool("test", "Test tool", "ok"),
}
executor := NewCodeExecutor(LanguagePython, toolList)
if executor == nil {
t.Error("NewCodeExecutor should return the executor")
}
// Verify that logging works with package-level logger
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
}
// TestSanitizeFunctionNameEdgeCases tests edge cases for sanitizeFunctionName
func TestSanitizeFunctionNameEdgeCases(t *testing.T) {
tests := []struct {
name string
input string
expected string
}{
{"with dashes", "my-tool-name", "my_tool_name"},
{"with spaces", "my tool name", "my_tool_name"},
{"with dots", "my.tool.name", "my_tool_name"},
{"starts with number", "123tool", "tool_123tool"},
{"mixed characters", "my-tool.name 123", "my_tool_name_123"},
{"empty string", "", ""},
{"already valid", "my_tool_name", "my_tool_name"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := sanitizeFunctionName(tt.input)
if result != tt.expected {
t.Errorf("sanitizeFunctionName(%q) = %q, want %q", tt.input, result, tt.expected)
}
})
}
}
// TestExecutorWithEmptyTools tests executor with no tools
func TestExecutorWithEmptyTools(t *testing.T) {
executor := NewCodeExecutor(LanguagePython, []tools.Tool{})
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor with empty tools: %v", err)
}
defer executor.Stop(ctx)
// Verify server URL is available even with no tools
if executor.GetToolServerURL() == "" {
t.Error("Expected tool server URL even with empty tools")
}
}
// TestExecutorTimeout tests code execution timeout
func TestExecutorTimeoutShort(t *testing.T) {
toolList := []tools.Tool{
newMockTool("slow", "Slow tool", "ok"),
}
executor := NewCodeExecutor(LanguagePython, toolList)
executor.Timeout = 100 * time.Millisecond // Very short timeout
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Python code that sleeps longer than timeout
code := `
import time
time.sleep(1) # Sleep for 1 second
print("done")
`
_, err := executor.Execute(ctx, code)
// Should timeout but not panic
if err == nil {
t.Log("Expected timeout error, but execution completed")
// This is not necessarily a failure - execution might complete quickly
}
}
// TestExecutorWithMalformedCode tests execution of malformed code
func TestExecutorWithMalformedCode(t *testing.T) {
toolList := []tools.Tool{
newMockTool("test", "Test tool", "ok"),
}
executor := NewCodeExecutor(LanguagePython, toolList)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Malformed Python code
code := `
this is not valid python syntax !!!
`
result, err := executor.Execute(ctx, code)
// Should return error or result with error in output
if err == nil && !strings.Contains(result.Output, "SyntaxError") {
t.Error("Expected syntax error in output for malformed code")
}
}
// TestExecutorWithLargeCode tests execution of large code blocks
func TestExecutorWithLargeCode(t *testing.T) {
toolList := []tools.Tool{
newMockTool("test", "Test tool", "ok"),
}
executor := NewCodeExecutor(LanguagePython, toolList)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Generate large code block (many print statements)
var codeBuilder strings.Builder
for i := range 100 {
codeBuilder.WriteString("print('Line " + string(rune(i)) + "')\n")
}
_, err := executor.Execute(ctx, codeBuilder.String())
if err != nil {
t.Errorf("Failed to execute large code block: %v", err)
}
}
// TestExecutorWithSpecialCharacters tests code with special characters
func TestExecutorWithSpecialCharacters(t *testing.T) {
toolList := []tools.Tool{
newMockTool("test", "Test tool", "ok"),
}
executor := NewCodeExecutor(LanguagePython, toolList)
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start executor: %v", err)
}
defer executor.Stop(ctx)
// Code with various special characters
code := `
# Test with special characters: © ® ™ § ¶ • ª º « »
print("Hello 世界! 🌍")
print("Special chars: ñ é à ü")
`
result, err := executor.Execute(ctx, code)
if err != nil {
t.Errorf("Failed to execute code with special characters: %v", err)
}
if result.Output == "" {
t.Error("Expected non-empty output for special character code")
}
}
// TestStopWithoutStart tests stopping executor that was never started
func TestStopBeforeStart(t *testing.T) {
executor := NewCodeExecutor(LanguagePython, []tools.Tool{})
ctx := context.Background()
// Stop without starting should not panic
err := executor.Stop(ctx)
if err != nil {
// This is acceptable - some implementations might return error
t.Logf("Stop without Start returned error: %v", err)
}
}
// TestMultipleStarts tests starting executor multiple times
func TestMultipleStarts(t *testing.T) {
executor := NewCodeExecutor(LanguagePython, []tools.Tool{})
ctx := context.Background()
// First start
if err := executor.Start(ctx); err != nil {
t.Fatalf("First start failed: %v", err)
}
// Second start should return error
err := executor.Start(ctx)
if err == nil {
t.Error("Expected error when starting already started executor")
}
executor.Stop(ctx)
}
// TestExecutorWorkDir tests custom work directory
func TestExecutorWorkDir(t *testing.T) {
executor := NewCodeExecutor(LanguagePython, []tools.Tool{})
// Verify default work dir is set
if executor.WorkDir == "" {
t.Error("Expected default WorkDir to be set")
}
// Change work dir
executor.WorkDir = "/tmp"
if executor.WorkDir != "/tmp" {
t.Error("Failed to set custom WorkDir")
}
}
// TestExecutorModeDirect tests Direct mode specific behavior
func TestExecutorModeDirectSpecific(t *testing.T) {
toolList := []tools.Tool{
newMockTool("test", "Test tool", "ok"),
}
executor := NewCodeExecutorWithMode(LanguagePython, toolList, ModeDirect)
if executor.Mode != ModeDirect {
t.Errorf("Expected ModeDirect, got %v", executor.Mode)
}
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start in Direct mode: %v", err)
}
defer executor.Stop(ctx)
// In Direct mode, tool server should be available (for generic tools)
if executor.GetToolServerURL() == "" {
t.Error("Expected tool server URL in Direct mode")
}
}
// TestExecutorModeServer tests Server mode specific behavior
func TestExecutorModeServerSpecific(t *testing.T) {
toolList := []tools.Tool{
newMockTool("test", "Test tool", "ok"),
}
executor := NewCodeExecutorWithMode(LanguagePython, toolList, ModeServer)
if executor.Mode != ModeServer {
t.Errorf("Expected ModeServer, got %v", executor.Mode)
}
ctx := context.Background()
if err := executor.Start(ctx); err != nil {
t.Fatalf("Failed to start in Server mode: %v", err)
}
defer executor.Stop(ctx)
// In Server mode, tool server should be available
if executor.GetToolServerURL() == "" {
t.Error("Expected tool server URL in Server mode")
}
}
// TestGetToolServerURLBeforeStart tests GetToolServerURL before Start
func TestGetToolServerURLBeforeStart(t *testing.T) {
executor := NewCodeExecutor(LanguagePython, []tools.Tool{})
// GetToolServerURL before Start returns URL with port 0
url := executor.GetToolServerURL()
if !strings.Contains(url, "127.0.0.1") {
t.Errorf("Expected URL to contain localhost, got %s", url)
}
}
// TestExecutionResultStructure tests ExecutionResult structure
func TestExecutionResultStructure(t *testing.T) {
result := &ExecutionResult{
Output: "test output",
Error: nil,
Stdout: "stdout content",
Stderr: "stderr content",
}
if result.Output != "test output" {
t.Error("ExecutionResult.Output not set correctly")
}
if result.Stdout != "stdout content" {
t.Error("ExecutionResult.Stdout not set correctly")
}
if result.Stderr != "stderr content" {
t.Error("ExecutionResult.Stderr not set correctly")
}
if result.Error != nil {
t.Error("ExecutionResult.Error should be nil")
}
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/llms/doubao/options.go | llms/doubao/options.go | package doubao
import (
"net/http"
"os"
"github.com/tmc/langchaingo/callbacks"
)
// ModelName represents the model identifier for Doubao (Volcengine Ark) API.
//
// IMPORTANT: You should use your custom Endpoint ID (推理接入点ID) as the model name.
// To create an endpoint and get your Endpoint ID, visit:
// https://www.volcengine.com/docs/82379/1330310
//
// Example usage:
//
// llm, err := doubao.New(
// doubao.WithAPIKey("your-api-key"),
// doubao.WithModel("your-endpoint-id"), // Use your Endpoint ID directly
// )
type ModelName string
type options struct {
apiKey string
accessKey string
secretKey string
model ModelName
embeddingModel ModelName
httpClient *http.Client
callbacksHandler callbacks.Handler
baseURL string
region string
}
// Option is a function that configures an LLM.
type Option func(*options)
// WithAPIKey sets the API key for the LLM (recommended method).
func WithAPIKey(apiKey string) Option {
return func(opts *options) {
opts.apiKey = apiKey
}
}
// WithAccessKey sets the Access Key for AK/SK authentication.
func WithAccessKey(accessKey string) Option {
return func(opts *options) {
opts.accessKey = accessKey
}
}
// WithSecretKey sets the Secret Key for AK/SK authentication.
func WithSecretKey(secretKey string) Option {
return func(opts *options) {
opts.secretKey = secretKey
}
}
// WithModel sets the model name for the LLM.
// You should use your custom Endpoint ID as the model name.
// To create an endpoint and get your Endpoint ID, visit: https://www.volcengine.com/docs/82379/1330310
func WithModel(model ModelName) Option {
return func(opts *options) {
opts.model = model
}
}
// WithEmbeddingModel sets the embedding model name.
// You should use your custom Endpoint ID as the model name.
func WithEmbeddingModel(model ModelName) Option {
return func(opts *options) {
opts.embeddingModel = model
}
}
// WithHTTPClient sets the HTTP client for the LLM.
func WithHTTPClient(client *http.Client) Option {
return func(opts *options) {
opts.httpClient = client
}
}
// WithCallbacks sets the callbacks handler for the LLM.
func WithCallbacks(handler callbacks.Handler) Option {
return func(opts *options) {
opts.callbacksHandler = handler
}
}
// WithBaseURL sets the base URL for the LLM API.
// Default is "https://ark.cn-beijing.volces.com/api/v3".
func WithBaseURL(baseURL string) Option {
return func(opts *options) {
opts.baseURL = baseURL
}
}
// WithRegion sets the region for the LLM API.
// Default is "cn-beijing".
func WithRegion(region string) Option {
return func(opts *options) {
opts.region = region
}
}
// getEnvOrDefault retrieves an environment variable or returns the default value.
func getEnvOrDefault(key, defaultValue string) string {
if value := os.Getenv(key); value != "" {
return value
}
return defaultValue
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/llms/doubao/doubaollm.go | llms/doubao/doubaollm.go | package doubao
import (
"context"
"errors"
"fmt"
"strings"
"github.com/tmc/langchaingo/callbacks"
"github.com/tmc/langchaingo/llms"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime/model"
)
var (
ErrEmptyResponse = errors.New("no response")
ErrNoAuth = errors.New("no authentication provided")
)
// LLM is a client for Doubao (Volcengine Ark) LLM.
// It supports chat completions and embeddings using the volcengine-go-sdk.
type LLM struct {
client *arkruntime.Client
model ModelName
embeddingModel ModelName
CallbacksHandler callbacks.Handler
}
var _ llms.Model = (*LLM)(nil)
// New returns a new Doubao LLM client.
//
// Authentication options (choose one):
// 1. WithAPIKey(apiKey) - API Key authentication (recommended)
// 2. WithAccessKey(ak) + WithSecretKey(sk) - AK/SK authentication
//
// Model configuration:
// - WithModel(endpointID) - Set your custom Endpoint ID for chat completion
// - WithEmbeddingModel(endpointID) - Set your custom Endpoint ID for embeddings
//
// To create an endpoint and get your Endpoint ID, visit:
// https://www.volcengine.com/docs/82379/1330310
//
// Environment variables:
// - DOUBAO_API_KEY - API Key for authentication
// - DOUBAO_ACCESS_KEY - Access Key for AK/SK authentication
// - DOUBAO_SECRET_KEY - Secret Key for AK/SK authentication
//
// Example:
//
// llm, err := doubao.New(
// doubao.WithAPIKey("your-api-key"),
// doubao.WithModel("your-chat-endpoint-id"),
// doubao.WithEmbeddingModel("your-embedding-endpoint-id"),
// )
func New(opts ...Option) (*LLM, error) {
options := &options{
apiKey: getEnvOrDefault("DOUBAO_API_KEY", ""),
accessKey: getEnvOrDefault("DOUBAO_ACCESS_KEY", ""),
secretKey: getEnvOrDefault("DOUBAO_SECRET_KEY", ""),
model: "doubao-seed-1-8-251215", // 默认模型
embeddingModel: "", // Use your Endpoint ID
baseURL: "https://ark.cn-beijing.volces.com/api/v3",
region: "cn-beijing",
}
for _, opt := range opts {
opt(options)
}
// Validate authentication
if options.apiKey == "" && (options.accessKey == "" || options.secretKey == "") {
return nil, fmt.Errorf("%w: please provide API key or AccessKey/SecretKey", ErrNoAuth)
}
// Create client config options
clientOpts := []arkruntime.ConfigOption{
arkruntime.WithBaseUrl(options.baseURL),
arkruntime.WithRegion(options.region),
}
if options.httpClient != nil {
clientOpts = append(clientOpts, arkruntime.WithHTTPClient(options.httpClient))
}
// Create client based on authentication method
var client *arkruntime.Client
if options.apiKey != "" {
// API Key authentication
client = arkruntime.NewClientWithApiKey(options.apiKey, clientOpts...)
} else {
// AK/SK authentication
client = arkruntime.NewClientWithAkSk(options.accessKey, options.secretKey, clientOpts...)
}
return &LLM{
client: client,
model: options.model,
embeddingModel: options.embeddingModel,
CallbacksHandler: options.callbacksHandler,
}, nil
}
// Call generates a response from the LLM for the given prompt.
func (o *LLM) Call(ctx context.Context, prompt string, options ...llms.CallOption) (string, error) {
return llms.GenerateFromSinglePrompt(ctx, o, prompt, options...)
}
// GenerateContent implements the Model interface.
// Uses Doubao chat completion API for text generation.
func (o *LLM) GenerateContent(ctx context.Context, messages []llms.MessageContent, options ...llms.CallOption) (*llms.ContentResponse, error) {
if len(messages) == 0 {
return nil, errors.New("no messages provided")
}
// Parse call options
opts := llms.CallOptions{}
for _, opt := range options {
opt(&opts)
}
// Convert langchaingo messages to arkruntime messages
arkMessages := make([]*model.ChatCompletionMessage, 0, len(messages))
for _, msg := range messages {
arkMsg, err := convertMessage(msg)
if err != nil {
return nil, fmt.Errorf("convert message: %w", err)
}
arkMessages = append(arkMessages, arkMsg)
}
// Determine model to use
modelName := o.model
if opts.Model != "" {
modelName = ModelName(opts.Model)
}
// Build chat request
req := &model.ChatCompletionRequest{ // nolint:staticcheck
Model: string(modelName),
Messages: arkMessages,
}
// Add tools if provided
if len(opts.Tools) > 0 {
tools := make([]*model.Tool, 0, len(opts.Tools))
for _, tool := range opts.Tools {
tools = append(tools, &model.Tool{
Type: model.ToolTypeFunction,
Function: &model.FunctionDefinition{
Name: tool.Function.Name,
Description: tool.Function.Description,
Parameters: tool.Function.Parameters,
},
})
}
req.Tools = tools
}
// Set tool choice if specified
if opts.ToolChoice != nil {
switch v := opts.ToolChoice.(type) {
case string:
// String type: "none", "auto", "required"
switch v {
case "none":
req.ToolChoice = model.ToolChoiceStringTypeNone
case "required":
req.ToolChoice = model.ToolChoiceStringTypeRequired
case "auto":
req.ToolChoice = model.ToolChoiceStringTypeAuto
default:
req.ToolChoice = model.ToolChoiceStringTypeAuto
}
case llms.ToolChoice:
// ToolChoice struct
switch v.Type {
case "none":
req.ToolChoice = model.ToolChoiceStringTypeNone
case "required":
req.ToolChoice = model.ToolChoiceStringTypeRequired
case "auto":
req.ToolChoice = model.ToolChoiceStringTypeAuto
case "function":
if v.Function != nil {
req.ToolChoice = &model.ToolChoice{
Type: model.ToolTypeFunction,
Function: model.ToolChoiceFunction{Name: v.Function.Name},
}
} else {
req.ToolChoice = model.ToolChoiceStringTypeAuto
}
default:
req.ToolChoice = model.ToolChoiceStringTypeAuto
}
default:
req.ToolChoice = model.ToolChoiceStringTypeAuto
}
}
// Set optional parameters
if opts.Temperature > 0 {
req.Temperature = float32(opts.Temperature)
}
if opts.TopP > 0 {
req.TopP = float32(opts.TopP)
}
if opts.MaxTokens > 0 {
req.MaxTokens = int(opts.MaxTokens)
}
// Non-streaming request
resp, err := o.client.CreateChatCompletion(ctx, req)
if err != nil {
return nil, fmt.Errorf("create chat completion: %w", err)
}
if len(resp.Choices) == 0 {
return nil, ErrEmptyResponse
}
// Convert response to langchaingo format
choices := make([]*llms.ContentChoice, 0, len(resp.Choices))
for _, choice := range resp.Choices {
content := getContentString(choice.Message.Content)
stopReason := string(choice.FinishReason)
contentChoice := &llms.ContentChoice{
Content: content,
StopReason: stopReason,
}
// Handle ToolCalls
if len(choice.Message.ToolCalls) > 0 {
toolCalls := make([]llms.ToolCall, 0, len(choice.Message.ToolCalls))
for _, tc := range choice.Message.ToolCalls {
toolCalls = append(toolCalls, llms.ToolCall{
ID: tc.ID,
Type: string(tc.Type),
FunctionCall: &llms.FunctionCall{
Name: tc.Function.Name,
Arguments: tc.Function.Arguments,
},
})
}
contentChoice.ToolCalls = toolCalls
}
// Handle legacy FunctionCall (for backward compatibility)
if choice.Message.FunctionCall != nil {
contentChoice.FuncCall = &llms.FunctionCall{
Name: choice.Message.FunctionCall.Name,
Arguments: choice.Message.FunctionCall.Arguments,
}
}
choices = append(choices, contentChoice)
}
return &llms.ContentResponse{
Choices: choices,
}, nil
}
// CreateEmbedding generates embeddings for the given texts using Doubao embedding models.
//
// Supported embedding models:
// - doubao-embedding: 基础向量化模型
// - doubao-embedding-large: 大型向量化模型
// - doubao-embedding-vision: 多模态向量化模型
//
// API documentation: https://www.volcengine.com/docs/82379/1521766
func (o *LLM) CreateEmbedding(ctx context.Context, texts []string) ([][]float32, error) {
if len(texts) == 0 {
return nil, errors.New("texts cannot be empty")
}
// Build embedding request
req := model.EmbeddingRequestStrings{
Model: string(o.embeddingModel),
Input: texts,
}
// Create embeddings
resp, err := o.client.CreateEmbeddings(ctx, req)
if err != nil {
return nil, fmt.Errorf("create embeddings: %w", err)
}
if len(resp.Data) == 0 {
return nil, ErrEmptyResponse
}
// Convert response to [][]float32 format
embeddings := make([][]float32, 0, len(resp.Data))
for i := range resp.Data {
// Sort by index to ensure correct order
idx := resp.Data[i].Index
if idx >= len(embeddings) {
// Extend slice if needed
newEmbeddings := make([][]float32, idx+1)
copy(newEmbeddings, embeddings)
embeddings = newEmbeddings
}
embeddings[idx] = resp.Data[i].Embedding
}
return embeddings, nil
}
// convertMessage converts a langchaingo MessageContent to an arkruntime ChatCompletionMessage.
func convertMessage(msg llms.MessageContent) (*model.ChatCompletionMessage, error) {
// Get role as string
role := string(msg.Role)
if len(msg.Parts) == 0 {
return nil, errors.New("message has no parts")
}
// Create ChatCompletionMessage
arkMsg := &model.ChatCompletionMessage{
Role: role,
}
// Process parts based on role
for _, part := range msg.Parts {
switch p := part.(type) {
case llms.TextContent:
// Text content
if arkMsg.Content == nil {
arkMsg.Content = createMessageContent(p.Text)
}
case llms.ToolCallResponse:
// Tool response (from tool role)
if role == "tool" {
arkMsg.Content = createMessageContent(p.Content)
// Also set ToolCallID if available
if p.ToolCallID != "" {
arkMsg.ToolCallID = p.ToolCallID
}
}
}
}
// For tool messages, ensure content exists
if role == "tool" && arkMsg.Content == nil {
var content strings.Builder
for _, part := range msg.Parts {
if text, ok := part.(llms.TextContent); ok {
content.WriteString(text.Text)
} else if tr, ok := part.(llms.ToolCallResponse); ok {
content.WriteString(tr.Content)
if tr.ToolCallID != "" {
arkMsg.ToolCallID = tr.ToolCallID
}
}
}
if content.String() != "" {
arkMsg.Content = createMessageContent(content.String())
}
}
// Ensure content is set for non-tool messages
if arkMsg.Content == nil && role != "tool" {
var content strings.Builder
for _, part := range msg.Parts {
if text, ok := part.(llms.TextContent); ok {
content.WriteString(text.Text)
}
}
contentStr := content.String()
if contentStr == "" {
return nil, errors.New("empty message content")
}
arkMsg.Content = createMessageContent(contentStr)
}
return arkMsg, nil
}
// createMessageContent creates a ChatCompletionMessageContent from a string.
func createMessageContent(s string) *model.ChatCompletionMessageContent {
return &model.ChatCompletionMessageContent{
StringValue: &s,
ListValue: nil,
}
}
// getContentString extracts the string content from ChatCompletionMessageContent.
func getContentString(content *model.ChatCompletionMessageContent) string {
if content == nil {
return ""
}
if content.StringValue != nil {
return *content.StringValue
}
if len(content.ListValue) > 0 {
var parts []string
for _, part := range content.ListValue {
if part.Type == model.ChatCompletionMessageContentPartTypeText {
parts = append(parts, part.Text)
}
}
return strings.Join(parts, "")
}
return ""
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
smallnest/langgraphgo | https://github.com/smallnest/langgraphgo/blob/600df7fe3e6254f2329f606732feaecfbd52d9f2/llms/doubao/doubaollm_test.go | llms/doubao/doubaollm_test.go | package doubao
import (
"context"
"os"
"testing"
"github.com/tmc/langchaingo/llms"
"github.com/volcengine/volcengine-go-sdk/service/arkruntime/model"
)
// getTestModel returns the model name from env or empty string.
//
// IMPORTANT: The Doubao API requires custom Endpoint IDs that you create in the
// Volcengine console. Set the DOUBAO_MODEL environment variable to your
// custom Endpoint ID to run tests with your specific endpoint.
//
// To get your Endpoint ID, visit: https://www.volcengine.com/docs/82379/1330310
func getTestModel() ModelName {
return ModelName(getEnvOrDefault("DOUBAO_MODEL", ""))
}
// getTestEmbeddingModel returns the embedding model name from env or empty string.
//
// IMPORTANT: Set the DOUBAO_EMBEDDING_MODEL environment variable to your
// custom embedding Endpoint ID to run embedding tests.
func getTestEmbeddingModel() ModelName {
return ModelName(getEnvOrDefault("DOUBAO_EMBEDDING_MODEL", ""))
}
// TestLLM_Create tests the LLM creation with various options.
func TestLLM_Create(t *testing.T) {
tests := []struct {
name string
opts []Option
wantErr bool
}{
{
name: "with api key",
opts: []Option{
WithAPIKey("test-key"),
},
wantErr: false,
},
{
name: "with api key and model",
opts: []Option{
WithAPIKey("test-key"),
WithModel("test-endpoint-id"),
},
wantErr: false,
},
{
name: "with ak/sk",
opts: []Option{
WithAccessKey("test-ak"),
WithSecretKey("test-sk"),
},
wantErr: false,
},
{
name: "no authentication",
opts: []Option{},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// For the "no authentication" test, temporarily clear env vars
if tt.name == "no authentication" {
oldAPIKey := os.Getenv("DOUBAO_API_KEY")
oldAccessKey := os.Getenv("DOUBAO_ACCESS_KEY")
oldSecretKey := os.Getenv("DOUBAO_SECRET_KEY")
defer func() {
if oldAPIKey != "" {
os.Setenv("DOUBAO_API_KEY", oldAPIKey)
} else {
os.Unsetenv("DOUBAO_API_KEY")
}
if oldAccessKey != "" {
os.Setenv("DOUBAO_ACCESS_KEY", oldAccessKey)
} else {
os.Unsetenv("DOUBAO_ACCESS_KEY")
}
if oldSecretKey != "" {
os.Setenv("DOUBAO_SECRET_KEY", oldSecretKey)
} else {
os.Unsetenv("DOUBAO_SECRET_KEY")
}
}()
os.Unsetenv("DOUBAO_API_KEY")
os.Unsetenv("DOUBAO_ACCESS_KEY")
os.Unsetenv("DOUBAO_SECRET_KEY")
}
llm, err := New(tt.opts...)
if (err != nil) != tt.wantErr {
t.Errorf("New() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !tt.wantErr && llm == nil {
t.Error("New() returned nil LLM")
}
})
}
}
// TestLLM_GenerateContent tests the content generation with real API.
// Skipped if DOUBAO_API_KEY or DOUBAO_MODEL is not set.
//
// IMPORTANT: This test requires DOUBAO_MODEL to be set to your custom Endpoint ID.
func TestLLM_GenerateContent(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
messages := []llms.MessageContent{
{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart("Hello, how are you?"),
},
},
}
resp, err := llm.GenerateContent(ctx, messages)
if err != nil {
t.Fatalf("Failed to generate content: %v", err)
}
if len(resp.Choices) == 0 {
t.Fatal("No choices in response")
}
content := resp.Choices[0].Content
if content == "" {
t.Error("Empty response content")
}
t.Logf("Response: %s", content)
t.Logf("StopReason: %s", resp.Choices[0].StopReason)
}
// TestLLM_CreateEmbedding tests the embedding generation with real API.
// Skipped if DOUBAO_API_KEY or DOUBAO_EMBEDDING_MODEL is not set.
func TestLLM_CreateEmbedding(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
embeddingModel := getTestEmbeddingModel()
if embeddingModel == "" {
t.Skip("DOUBAO_EMBEDDING_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithEmbeddingModel(embeddingModel),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
texts := []string{"Hello world"}
embeddings, err := llm.CreateEmbedding(ctx, texts)
if err != nil {
t.Fatalf("Failed to create embedding: %v", err)
}
if len(embeddings) != 1 {
t.Fatalf("Expected 1 embedding, got %d", len(embeddings))
}
if len(embeddings[0]) == 0 {
t.Fatal("Empty embedding")
}
t.Logf("Embedding dimension: %d", len(embeddings[0]))
}
// TestLLM_CreateEmbeddingMultiple tests embedding generation for multiple texts.
func TestLLM_CreateEmbeddingMultiple(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
embeddingModel := getTestEmbeddingModel()
if embeddingModel == "" {
t.Skip("DOUBAO_EMBEDDING_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithEmbeddingModel(embeddingModel),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
texts := []string{"Hello", "World"}
embeddings, err := llm.CreateEmbedding(ctx, texts)
if err != nil {
t.Fatalf("Failed to create embedding: %v", err)
}
if len(embeddings) != 2 {
t.Fatalf("Expected 2 embeddings, got %d", len(embeddings))
}
for i, emb := range embeddings {
if len(emb) == 0 {
t.Errorf("Empty embedding at index %d", i)
}
t.Logf("Embedding %d dimension: %d", i, len(emb))
}
}
// TestLLM_Call tests the Call method.
func TestLLM_Call(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
response, err := llm.Call(ctx, "What is 2+2?")
if err != nil {
t.Fatalf("Failed to call LLM: %v", err)
}
if response == "" {
t.Error("Empty response")
}
t.Logf("Response: %s", response)
}
// TestLLM_Conversation tests a multi-turn conversation.
func TestLLM_Conversation(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
messages := []llms.MessageContent{
{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart("My name is Alice"),
},
},
{
Role: llms.ChatMessageTypeAI,
Parts: []llms.ContentPart{
llms.TextPart("Hello Alice! Nice to meet you."),
},
},
{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart("What's my name?"),
},
},
}
resp, err := llm.GenerateContent(ctx, messages)
if err != nil {
t.Fatalf("Failed to generate content: %v", err)
}
if len(resp.Choices) == 0 {
t.Fatal("No choices in response")
}
content := resp.Choices[0].Content
t.Logf("Response: %s", content)
}
// TestLLM_WithAKSK tests AK/SK authentication.
func TestLLM_WithAKSK(t *testing.T) {
ak := os.Getenv("DOUBAO_ACCESS_KEY")
sk := os.Getenv("DOUBAO_SECRET_KEY")
if ak == "" || sk == "" {
t.Skip("DOUBAO_ACCESS_KEY and DOUBAO_SECRET_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
llm, err := New(
WithAccessKey(ak),
WithSecretKey(sk),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
response, err := llm.Call(ctx, "Say hello")
if err != nil {
t.Fatalf("Failed to call LLM: %v", err)
}
if response == "" {
t.Error("Empty response")
}
t.Logf("Response: %s", response)
}
// TestLLM_EmbeddingLarge tests the large embedding model.
func TestLLM_EmbeddingLarge(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
embeddingModel := getTestEmbeddingModel()
if embeddingModel == "" {
t.Skip("DOUBAO_EMBEDDING_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithEmbeddingModel(embeddingModel),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
embeddings, err := llm.CreateEmbedding(ctx, []string{"test text for large embedding model"})
if err != nil {
t.Fatalf("Failed to create embedding: %v", err)
}
if len(embeddings) != 1 {
t.Fatalf("Expected 1 embedding, got %d", len(embeddings))
}
dim := len(embeddings[0])
t.Logf("Doubao Embedding dimension: %d", dim)
}
// TestLLM_DifferentModels tests different model types.
func TestLLM_DifferentModels(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
// Test with the default model from env
llm, err := New(
WithAPIKey(apiKey),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
response, err := llm.Call(ctx, "Say hello")
if err != nil {
t.Logf("Model %s error: %v", model, err)
return
}
if response == "" {
t.Errorf("Model %s returned empty response", model)
}
t.Logf("Model %s response: %s", model, response)
}
// TestLLM_Streaming tests streaming response.
func TestLLM_Streaming(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
messages := []llms.MessageContent{
{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart("Count from 1 to 5"),
},
},
}
resp, err := llm.GenerateContent(ctx, messages)
if err != nil {
t.Fatalf("Failed to generate content: %v", err)
}
if len(resp.Choices) == 0 {
t.Fatal("No choices in response")
}
t.Logf("Response: %s", resp.Choices[0].Content)
}
// TestLLM_ToolCall tests tool call functionality.
// Skipped if DOUBAO_API_KEY or DOUBAO_MODEL is not set.
func TestLLM_ToolCall(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
// Define a simple tool for getting weather
tools := []llms.Tool{
{
Type: "function",
Function: &llms.FunctionDefinition{
Name: "get_weather",
Description: "Get the current weather in a given location",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"location": map[string]any{
"type": "string",
"description": "The city and state, e.g. San Francisco, CA",
},
"unit": map[string]any{
"type": "string",
"enum": []string{"celsius", "fahrenheit"},
"description": "The temperature unit to use",
},
},
"required": []string{"location"},
},
},
},
}
messages := []llms.MessageContent{
{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart("What's the weather like in San Francisco, CA?"),
},
},
}
resp, err := llm.GenerateContent(ctx, messages, llms.WithTools(tools))
if err != nil {
t.Fatalf("Failed to generate content: %v", err)
}
if len(resp.Choices) == 0 {
t.Fatal("No choices in response")
}
choice := resp.Choices[0]
t.Logf("Content: %s", choice.Content)
t.Logf("StopReason: %s", choice.StopReason)
// Check for tool calls
if len(choice.ToolCalls) > 0 {
t.Logf("Tool calls returned: %d", len(choice.ToolCalls))
for i, tc := range choice.ToolCalls {
t.Logf(" ToolCall[%d]: ID=%s, Type=%s, Function.Name=%s, Function.Arguments=%s",
i, tc.ID, tc.Type, tc.FunctionCall.Name, tc.FunctionCall.Arguments)
}
} else if choice.FuncCall != nil {
t.Logf("FuncCall returned: Name=%s, Arguments=%s",
choice.FuncCall.Name, choice.FuncCall.Arguments)
} else {
t.Log("No tool calls or function call in response")
}
}
// TestLLM_ToolChoice tests tool choice option.
// Skipped if DOUBAO_API_KEY or DOUBAO_MODEL is not set.
func TestLLM_ToolChoice(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
tools := []llms.Tool{
{
Type: "function",
Function: &llms.FunctionDefinition{
Name: "get_current_time",
Description: "Get the current time",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{},
},
},
},
}
tests := []struct {
name string
toolChoice any
desc string
}{
{
name: "tool choice auto",
toolChoice: "auto",
desc: "Model decides whether to call tools",
},
{
name: "tool choice none",
toolChoice: "none",
desc: "Model will not call tools",
},
{
name: "tool choice required",
toolChoice: llms.ToolChoice{
Type: "required",
},
desc: "Model must call a tool",
},
{
name: "tool choice specific function",
toolChoice: llms.ToolChoice{
Type: "function",
Function: &llms.FunctionReference{
Name: "get_current_time",
},
},
desc: "Model must call the specific function",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
messages := []llms.MessageContent{
{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart("What time is it?"),
},
},
}
resp, err := llm.GenerateContent(ctx, messages,
llms.WithTools(tools),
llms.WithToolChoice(tt.toolChoice),
)
if err != nil {
t.Fatalf("Failed to generate content: %v", err)
}
if len(resp.Choices) == 0 {
t.Fatal("No choices in response")
}
choice := resp.Choices[0]
t.Logf("Test: %s", tt.desc)
t.Logf("Content: %s", choice.Content)
t.Logf("StopReason: %s", choice.StopReason)
if len(choice.ToolCalls) > 0 {
t.Logf("Tool calls: %d", len(choice.ToolCalls))
}
})
}
}
// TestLLM_ToolResponse tests tool response handling.
// Skipped if DOUBAO_API_KEY or DOUBAO_MODEL is not set.
func TestLLM_ToolResponse(t *testing.T) {
apiKey := os.Getenv("DOUBAO_API_KEY")
if apiKey == "" {
t.Skip("DOUBAO_API_KEY not set")
}
model := getTestModel()
if model == "" {
t.Skip("DOUBAO_MODEL not set")
}
llm, err := New(
WithAPIKey(apiKey),
WithModel(model),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
// Simulate a conversation with tool call and response
messages := []llms.MessageContent{
{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart("What's the weather like in Beijing?"),
},
},
// Simulated tool response
{
Role: llms.ChatMessageTypeTool,
Parts: []llms.ContentPart{
llms.ToolCallResponse{
ToolCallID: "call_123",
Content: `{"temperature": "22°C", "condition": "Sunny"}`,
},
},
},
}
resp, err := llm.GenerateContent(ctx, messages)
if err != nil {
t.Fatalf("Failed to generate content: %v", err)
}
if len(resp.Choices) == 0 {
t.Fatal("No choices in response")
}
content := resp.Choices[0].Content
t.Logf("Response after tool call: %s", content)
if content == "" {
t.Error("Empty response after tool call")
}
}
// TestLLM_ConvertMessageWithToolResponse tests the convertMessage function with tool response.
func TestLLM_ConvertMessageWithToolResponse(t *testing.T) {
tests := []struct {
name string
msg llms.MessageContent
wantErr bool
validate func(*testing.T, *model.ChatCompletionMessage)
}{
{
name: "tool response with ToolCallID",
msg: llms.MessageContent{
Role: llms.ChatMessageTypeTool,
Parts: []llms.ContentPart{
llms.ToolCallResponse{
ToolCallID: "test-call-id",
Content: `{"result": "success"}`,
},
},
},
wantErr: false,
validate: func(t *testing.T, m *model.ChatCompletionMessage) {
if m.Role != "tool" {
t.Errorf("Expected role 'tool', got '%s'", m.Role)
}
if m.ToolCallID != "test-call-id" {
t.Errorf("Expected ToolCallID 'test-call-id', got '%s'", m.ToolCallID)
}
if m.Content == nil {
t.Error("Expected content to be set")
}
},
},
{
name: "tool response with text content",
msg: llms.MessageContent{
Role: llms.ChatMessageTypeTool,
Parts: []llms.ContentPart{
llms.TextPart("some text content"),
},
},
wantErr: false,
validate: func(t *testing.T, m *model.ChatCompletionMessage) {
if m.Role != "tool" {
t.Errorf("Expected role 'tool', got '%s'", m.Role)
}
if m.Content == nil {
t.Error("Expected content to be set")
}
},
},
{
name: "user message with text",
msg: llms.MessageContent{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{
llms.TextPart("Hello, how are you?"),
},
},
wantErr: false,
validate: func(t *testing.T, m *model.ChatCompletionMessage) {
if m.Role != string(llms.ChatMessageTypeHuman) {
t.Errorf("Expected role '%s', got '%s'", llms.ChatMessageTypeHuman, m.Role)
}
if m.Content == nil {
t.Error("Expected content to be set")
}
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
msg, err := convertMessage(tt.msg)
if (err != nil) != tt.wantErr {
t.Errorf("convertMessage() error = %v, wantErr %v", err, tt.wantErr)
return
}
if tt.wantErr {
return
}
if tt.validate != nil {
tt.validate(t, msg)
}
})
}
}
// TestGetContentString tests the getContentString helper function.
func TestGetContentString(t *testing.T) {
textPartType := model.ChatCompletionMessageContentPartTypeText
tests := []struct {
name string
content *model.ChatCompletionMessageContent
expected string
}{
{
name: "nil content",
content: nil,
expected: "",
},
{
name: "string value",
content: &model.ChatCompletionMessageContent{
StringValue: stringPtr("Hello, world!"),
},
expected: "Hello, world!",
},
{
name: "nil string value",
content: &model.ChatCompletionMessageContent{
StringValue: nil,
},
expected: "",
},
{
name: "empty list value",
content: &model.ChatCompletionMessageContent{
ListValue: []*model.ChatCompletionMessageContentPart{},
},
expected: "",
},
{
name: "list value with text parts",
content: &model.ChatCompletionMessageContent{
ListValue: []*model.ChatCompletionMessageContentPart{
{
Type: textPartType,
Text: "Hello, ",
},
{
Type: textPartType,
Text: "world!",
},
},
},
expected: "Hello, world!",
},
{
name: "list value with mixed parts",
content: &model.ChatCompletionMessageContent{
ListValue: []*model.ChatCompletionMessageContentPart{
{
Type: textPartType,
Text: "Text part",
},
{
Type: "other_type",
Text: "ignored",
},
},
},
expected: "Text part",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := getContentString(tt.content)
if result != tt.expected {
t.Errorf("getContentString() = %q, want %q", result, tt.expected)
}
})
}
}
// TestLLM_Options tests various LLM options.
func TestLLM_Options(t *testing.T) {
tests := []struct {
name string
opts []Option
wantErr bool
check func(*testing.T, *LLM)
}{
{
name: "with embedding model",
opts: []Option{
WithAPIKey("test-key"),
WithEmbeddingModel("embedding-endpoint-id"),
},
wantErr: false,
check: func(t *testing.T, llm *LLM) {
if llm.embeddingModel != "embedding-endpoint-id" {
t.Errorf("embeddingModel = %q, want %q", llm.embeddingModel, "embedding-endpoint-id")
}
},
},
{
name: "with base URL",
opts: []Option{
WithAPIKey("test-key"),
WithBaseURL("https://custom.endpoint.com/api/v3"),
},
wantErr: false,
check: func(t *testing.T, llm *LLM) {
// Verify the LLM was created successfully
if llm == nil {
t.Error("LLM is nil")
}
},
},
{
name: "with region",
opts: []Option{
WithAPIKey("test-key"),
WithRegion("us-east-1"),
},
wantErr: false,
check: func(t *testing.T, llm *LLM) {
// Verify the LLM was created successfully
if llm == nil {
t.Error("LLM is nil")
}
},
},
{
name: "with all options",
opts: []Option{
WithAPIKey("test-key"),
WithModel("model-endpoint-id"),
WithEmbeddingModel("embedding-endpoint-id"),
WithBaseURL("https://custom.endpoint.com/api/v3"),
WithRegion("cn-shanghai"),
},
wantErr: false,
check: func(t *testing.T, llm *LLM) {
if llm.model != "model-endpoint-id" {
t.Errorf("model = %q, want %q", llm.model, "model-endpoint-id")
}
if llm.embeddingModel != "embedding-endpoint-id" {
t.Errorf("embeddingModel = %q, want %q", llm.embeddingModel, "embedding-endpoint-id")
}
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
llm, err := New(tt.opts...)
if (err != nil) != tt.wantErr {
t.Errorf("New() error = %v, wantErr %v", err, tt.wantErr)
return
}
if tt.wantErr {
return
}
if tt.check != nil {
tt.check(t, llm)
}
})
}
}
// TestLLM_GenerateContent_EmptyMessages tests GenerateContent with empty messages.
func TestLLM_GenerateContent_EmptyMessages(t *testing.T) {
llm, err := New(WithAPIKey("test-key"))
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
_, err = llm.GenerateContent(ctx, []llms.MessageContent{})
if err == nil {
t.Error("Expected error for empty messages, got nil")
}
if err != nil && err.Error() != "no messages provided" {
t.Errorf("Expected 'no messages provided' error, got %v", err)
}
}
// TestLLM_CreateEmbedding_EmptyTexts tests CreateEmbedding with empty texts.
func TestLLM_CreateEmbedding_EmptyTexts(t *testing.T) {
llm, err := New(
WithAPIKey("test-key"),
WithEmbeddingModel("embedding-endpoint-id"),
)
if err != nil {
t.Fatalf("Failed to create LLM: %v", err)
}
ctx := context.Background()
_, err = llm.CreateEmbedding(ctx, []string{})
if err == nil {
t.Error("Expected error for empty texts, got nil")
}
}
// TestLLM_ConvertMessage_Errors tests convertMessage error cases.
func TestLLM_ConvertMessage_Errors(t *testing.T) {
tests := []struct {
name string
msg llms.MessageContent
wantErr bool
errMsg string
}{
{
name: "message with no parts",
msg: llms.MessageContent{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{},
},
wantErr: true,
errMsg: "message has no parts",
},
{
name: "message with empty content - actually works with empty string",
msg: llms.MessageContent{
Role: llms.ChatMessageTypeHuman,
Parts: []llms.ContentPart{llms.TextPart("")},
},
wantErr: false, // The code allows empty strings, it creates content with empty string
},
{
name: "tool message with no valid content",
msg: llms.MessageContent{
Role: llms.ChatMessageTypeTool,
Parts: []llms.ContentPart{},
},
wantErr: true,
errMsg: "message has no parts",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := convertMessage(tt.msg)
if (err != nil) != tt.wantErr {
t.Errorf("convertMessage() error = %v, wantErr %v", err, tt.wantErr)
return
}
if tt.wantErr && tt.errMsg != "" && err != nil {
if !containsString(err.Error(), tt.errMsg) {
t.Errorf("Expected error containing %q, got %q", tt.errMsg, err.Error())
}
}
})
}
}
// TestCreateMessageContent tests the createMessageContent helper function.
func TestCreateMessageContent(t *testing.T) {
tests := []struct {
name string
input string
}{
{
name: "normal text",
input: "Hello, world!",
},
{
name: "empty string",
input: "",
},
{
name: "special characters",
input: "Hello\nWorld\t!",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
content := createMessageContent(tt.input)
if content == nil {
t.Fatal("createMessageContent() returned nil")
}
if content.StringValue == nil {
t.Error("StringValue is nil")
} else if *content.StringValue != tt.input {
t.Errorf("StringValue = %q, want %q", *content.StringValue, tt.input)
}
if content.ListValue != nil {
t.Error("ListValue should be nil")
}
})
}
}
// Helper function to get a string pointer.
func stringPtr(s string) *string {
return &s
}
// Helper function to check if a string contains a substring.
func containsString(s, substr string) bool {
return len(s) >= len(substr) && (s == substr || len(substr) == 0 ||
(len(s) > len(substr) && containsSubstring(s, substr)))
}
func containsSubstring(s, substr string) bool {
for i := 0; i <= len(s)-len(substr); i++ {
if s[i:i+len(substr)] == substr {
return true
}
}
return false
}
| go | MIT | 600df7fe3e6254f2329f606732feaecfbd52d9f2 | 2026-01-07T10:38:05.929544Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.