GoLEM - Go Language Execution Model

GoLEM is a production-ready, scalable multi-agent system designed for modern AI applications. It provides a clean, extensible architecture for building intelligent agents that can collaborate, execute tasks, and integrate with various LLM providers.

• 🤖 Multi-Agent Architecture: Create and orchestrate multiple specialized AI agents
• 🧠 LLM Integration: Support for OpenAI, Anthropic, and Ollama providers
• 🔧 Built-in Tools: 8+ ready-to-use tools (Calculator, Search, Wikipedia, File System, etc.)
• 💾 Memory Management: Multiple backends (In-Memory, Redis, PostgreSQL, SQLite)
• 🌊 Workflow Orchestration: DAG-based task execution with dependency management
• 🔌 API Interfaces: Both REST and gRPC APIs with comprehensive endpoints
• 📊 Monitoring: Prometheus metrics, health checks, and observability
• 🐳 Container Ready: Full Docker and Kubernetes support
• ⚙️ Highly Configurable: Extensive configuration options with environment variable support

• Dynamic Agent Creation: Create specialized agents with custom LLM providers and tools
• Tool Integration: Extensible tool system with built-in safety mechanisms
• Conversation Memory: Persistent conversation history across sessions
• Multi-Provider Support: Switch between different LLM providers seamlessly

• Task Builder Pattern: Fluent API for creating complex tasks
• DAG Orchestration: Directed Acyclic Graph workflow execution
• Priority Queue: Task prioritization and scheduling
• Retry Mechanism: Automatic retry with exponential backoff
• Status Tracking: Real-time task and workflow status monitoring

• OpenAI: GPT-4, GPT-3.5-turbo with streaming support
• Anthropic: Claude 3 (Opus, Sonnet, Haiku) models
• Ollama: Local model execution support
• Streaming Responses: Real-time response streaming for all providers
• Tool Calling: Function calling capabilities where supported

• In-Memory: Fast, ephemeral storage for development
• Redis: Distributed caching with TTL support
• PostgreSQL: Full-featured relational database backend
• SQLite: Lightweight persistent storage
• Search Capabilities: Full-text search across all backends

• Comprehensive Endpoints: Agents, tasks, workflows, tools, memory management
• OpenAPI/Swagger: Auto-generated documentation
• Authentication: JWT, API key, and OAuth2 support
• Rate Limiting: Configurable request throttling
• CORS Support: Cross-origin request handling

• High Performance: Binary protocol for efficient communication
• Streaming Support: Real-time bidirectional streaming
• Type Safety: Strongly typed protobuf definitions
• Load Balancing: Native gRPC load balancing support

┌─────────────────────────────────────────────────────────────┐
│                      GoLEM Architecture                     │
├─────────────────────────────────────────────────────────────┤
│  API Layer          │  REST API  │  gRPC API  │  Metrics    │
├─────────────────────────────────────────────────────────────┤
│  Core Engine        │  Task Queue │ Workers   │  Event Bus  │
├─────────────────────────────────────────────────────────────┤
│  Agent System       │  Agents     │ Tools     │  Memory     │
├─────────────────────────────────────────────────────────────┤
│  LLM Providers      │  OpenAI     │ Anthropic │  Ollama     │
├─────────────────────────────────────────────────────────────┤
│  Storage Layer      │  Redis      │ PostgreSQL│  SQLite     │
└─────────────────────────────────────────────────────────────┘

• Task execution tracing
• Agent performance monitoring

package main

import (
    "context"
    "fmt"
    "log"
    
    "github.com/astrica1/GoLEM/pkg/golem"
    "github.com/astrica1/GoLEM/pkg/agent"
    "github.com/astrica1/GoLEM/pkg/task"
    "github.com/astrica1/GoLEM/pkg/llm/openai"
)

func main() {
    // Initialize GoLEM
    engine := golem.NewEngine()
    
    // Create LLM provider
    llmProvider := openai.NewProvider("your-api-key")
    
    // Create quantum scientist agent
    quantumScientist := agent.NewAgent("quantum-scientist", agent.Config{
        Role: "You are a quantum physics researcher",
        LLMProvider: llmProvider,
        Model: "gpt-4",
    })
    
    // Create speaker agent
    speaker := agent.NewAgent("speaker", agent.Config{
        Role: "You are a professional speaker who creates engaging presentations",
        LLMProvider: llmProvider,
        Model: "gpt-4",
    })
    
    // Register agents
    engine.RegisterAgent(quantumScientist)
    engine.RegisterAgent(speaker)
    
    // Create research task
    researchTask := task.NewTask("research-quantum", task.Config{
        Description: "Research recent quantum computing breakthroughs",
        AssignedAgent: "quantum-scientist",
    })
    
    // Create presentation task
    presentationTask := task.NewTask("create-presentation", task.Config{
        Description: "Create a 2000-word presentation about quantum computing",
        AssignedAgent: "speaker",
        Dependencies: []string{"research-quantum"},
    })
    
    // Execute workflow
    workflow := engine.NewWorkflow()
    workflow.AddTask(researchTask)
    workflow.AddTask(presentationTask)
    
    result, err := workflow.Execute(context.Background())
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Println("Workflow completed:", result)
}

GoLEM follows clean architecture principles with clear separation of concerns:

pkg/
├── golem/          # Core engine and orchestration
├── agent/          # Agent management and execution
├── task/           # Task definition and management  
├── llm/            # LLM provider integrations
├── memory/         # Memory and storage backends
├── tools/          # Built-in and custom tools
├── api/            # REST and gRPC interfaces
├── workflow/       # Workflow orchestration
└── utils/          # Utility functions

# config.yaml
golem:
  engine:
    max_concurrent_tasks: 10
    default_timeout: "30m"
    
  llm:
    openai:
      api_key: "${OPENAI_API_KEY}"
      base_url: "https://api.openai.com/v1"
    anthropic:
      api_key: "${ANTHROPIC_API_KEY}"
    ollama:
      base_url: "http://localhost:11434"
      
  memory:
    backend: "redis"
    redis:
      addr: "localhost:6379"
      password: ""
      db: 0
      
  api:
    rest:
      port: 8080
      enable_swagger: true
    grpc:
      port: 9090
      
  monitoring:
    prometheus:
      enabled: true
      port: 2112
    logging:
      level: "info"
      format: "json"

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

This project is licensed under the MIT License - see the LICENSE file for details.