Go-Calque

A composable AI agent framework for Go that makes it easy to build production-ready AI applications.

Developed by Calque AI

The Problem

Building AI apps in Go means wrestling with:

• Provider lock-in - Switching between OpenAI, Gemini, or local models requires rewriting code
• Conversation state - Managing chat history and context windows across requests
• Tool calling - Connecting AI to your Go functions with proper error handling
• Structured outputs - Getting reliable JSON responses that match your types
• RAG pipelines - Coordinating document retrieval, embedding, and generation

Go-Calque solves these with a simple, composable middleware pattern that feels native to Go.

Installation

go get github.com/calque-ai/go-calque

Quickstart

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/calque-ai/go-calque/pkg/calque"
    "github.com/calque-ai/go-calque/pkg/middleware/ai"
    "github.com/calque-ai/go-calque/pkg/middleware/ai/ollama"
)

func main() {
    client, err := ollama.New("llama3.2:3b")
    if err != nil {
        log.Fatal(err)
    }

    flow := calque.NewFlow().Use(ai.Agent(client))

    var result string
    err = flow.Run(context.Background(), "What's the capital of France?", &result)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(result)
}

Three lines to set up, one line to run.

What You Can Build

Chatbot with Memory

convMem := memory.NewConversation()

flow := calque.NewFlow().
    Use(convMem.Input(userID)).
    Use(ai.Agent(client)).
    Use(convMem.Output(userID))

AI with Tool Calling

calculator := tools.Simple("calc", "Math", calcFn)
weather := tools.Simple("weather", "Weather", weatherFn)

flow := calque.NewFlow().
    Use(ai.Agent(client, ai.WithTools(calculator, weather)))

Structured Output

flow := calque.NewFlow().
    Use(ai.Agent(client, ai.WithSchema(&MyType{})))

var result MyType
flow.Run(ctx, "Analyze this", convert.FromJSONSchema(&result))

RAG Pipeline

flow := calque.NewFlow().
    Use(retrieval.VectorSearch(store, opts)).
    Use(prompt.Template(ragTemplate)).
    Use(ai.Agent(client))

📖 See Getting Started Guide →

Why Go-Calque?

Features

Core

• AI Agents - OpenAI, Gemini, Ollama with unified interface
• Tool Calling - Auto-discovery and execution of Go functions
• Memory - Conversation history with configurable limits

Data Processing

• RAG & Retrieval - Vector search, context building, semantic filtering
• Converters - JSON, YAML, Protobuf, JSONSchema, SSE
• Flow Control - Retry, timeout, fallback, parallel, chain

Production

• Observability - Metrics, tracing, health checks, structured logging
• MCP Support - Model Context Protocol client
• Multi-Agent - Agent routing and load balancing

📖 See Full Middleware Reference →

Performance

Go-Calque is built for production AI workloads where LLM latency dominates.

📊 See Benchmark Analysis →

Documentation

Examples

Roadmap

Middleware

• ✅ Tool Calling - Function execution for AI agents
• ✅ Information Retrieval - Vector search, context building, semantic filtering
• ✅ Multi-Agent - Agent routing, load balancing, conditional routing
• ✅ HTTP/API Integration - Streaming responses
• ✅ Model Context Protocol - MCP client, natural language tools
• ✅ Observability - Metrics, tracing, health checks, structured logging
• 🔲 Guardrails & Safety - Input filtering, output validation

Framework

• 🔲 Vector-based semantic memory
• 🔲 Planning & reflection capabilities
• 🔲 Anthropic/Claude support

Contributing

1. Fork the repository
2. Create a feature branch
3. Add tests for new middleware
4. Submit a pull request

See AGENTS.md for development setup.

Contributors

Star History

License

Mozilla Public License 2.0 - see LICENSE file for details.