langchaingo

README

🎉 Join our new official Discord community! Connect with other LangChain Go developers, get help and contribute: Join Discord

🦜️🔗 LangChain Go

⚡ Building applications with LLMs through composability, with Go! ⚡

🤔 What is this?

This is the Go language implementation of LangChain.

📖 Documentation

• Documentation Site
• API Reference

🎉 Examples

See ./examples for example usage.

package main

import (
  "context"
  "fmt"
  "log"

  "github.com/iohub/langchaingo/llms"
  "github.com/iohub/langchaingo/llms/openai"
)

func main() {
  ctx := context.Background()
  llm, err := openai.New()
  if err != nil {
    log.Fatal(err)
  }
  prompt := "What would be a good company name for a company that makes colorful socks?"
  completion, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(completion)
}

$ go run .
Socktastic

Resources

Join the Discord server for support and discussions: Join Discord

Here are some links to blog posts and articles on using Langchain Go:

• Using Gemini models in Go with LangChainGo - Jan 2024
• Using Ollama with LangChainGo - Nov 2023
• Creating a simple ChatGPT clone with Go - Aug 2023
• Creating a ChatGPT Clone that Runs on Your Laptop with Go - Aug 2023

Contributors

There is a momentum for moving the development of langchaingo to a more community effort, if you are interested in being a maintainer or you are a contributor please join our Discord and let us know.

Documentation

Overview

Package langchaingo provides a Go implementation of LangChain, a framework for building applications with Large Language Models (LLMs) through composability.

LangchainGo enables developers to create powerful AI-driven applications by providing a unified interface to various LLM providers, vector databases, and other AI services. The framework emphasizes modularity, extensibility, and ease of use.

Core Components

The framework is organized around several key packages:

• github.com/iohub/langchaingo/llms: Interfaces and implementations for various language models (OpenAI, Anthropic, Google, etc.)
• github.com/iohub/langchaingo/chains: Composable operations that can be linked together to create complex workflows
• github.com/iohub/langchaingo/agents: Autonomous entities that can use tools to accomplish tasks
• github.com/iohub/langchaingo/embeddings: Text embedding functionality for semantic search and similarity
• github.com/iohub/langchaingo/vectorstores: Interfaces to vector databases for storing and querying embeddings
• github.com/iohub/langchaingo/memory: Conversation history and context management
• github.com/iohub/langchaingo/tools: External tool integrations (web search, calculators, databases, etc.)

Quick Start

Basic text generation with OpenAI:

import (
	"context"
	"log"

	"github.com/iohub/langchaingo/llms"
	"github.com/iohub/langchaingo/llms/openai"
)

ctx := context.Background()
llm, err := openai.New()
if err != nil {
	log.Fatal(err)
}

completion, err := llm.GenerateContent(ctx, []llms.MessageContent{
	llms.TextParts(llms.ChatMessageTypeHuman, "What is the capital of France?"),
})

Creating embeddings and using vector search:

import (
	"github.com/iohub/langchaingo/embeddings"
	"github.com/iohub/langchaingo/schema"
	"github.com/iohub/langchaingo/vectorstores/chroma"
)

// Create an embedder
embedder, err := embeddings.NewEmbedder(llm)
if err != nil {
	log.Fatal(err)
}

// Create a vector store
store, err := chroma.New(
	chroma.WithChromaURL("http://localhost:8000"),
	chroma.WithEmbedder(embedder),
)

// Add documents
docs := []schema.Document{
	{PageContent: "Paris is the capital of France"},
	{PageContent: "London is the capital of England"},
}
store.AddDocuments(ctx, docs)

// Search for similar documents
results, err := store.SimilaritySearch(ctx, "French capital", 1)

Building a chain for question answering:

import (
	"github.com/iohub/langchaingo/chains"
	"github.com/iohub/langchaingo/vectorstores"
)

chain := chains.NewRetrievalQAFromLLM(
	llm,
	vectorstores.ToRetriever(store, 3),
)

answer, err := chains.Run(ctx, chain, "What is the capital of France?")

Provider Support

LangchainGo supports numerous providers:

LLM Providers:

• OpenAI (GPT-3.5, GPT-4, GPT-4 Turbo)
• Anthropic (Claude family)
• Google AI (Gemini, PaLM)
• AWS Bedrock (Claude, Llama, Titan)
• Cohere
• Mistral AI
• Ollama (local models)
• Hugging Face Inference
• And many more...

Embedding Providers:

• OpenAI
• Hugging Face
• Jina AI
• Voyage AI
• Google Vertex AI
• AWS Bedrock

Vector Stores:

• Chroma
• Pinecone
• Weaviate
• Qdrant
• PostgreSQL with pgvector
• Redis
• Milvus
• MongoDB Atlas Vector Search
• OpenSearch
• Azure AI Search

Agents and Tools

Create agents that can use tools to accomplish complex tasks:

import (
	"github.com/iohub/langchaingo/agents"
	"github.com/iohub/langchaingo/tools/serpapi"
	"github.com/iohub/langchaingo/tools/calculator"
)

// Create tools
searchTool := serpapi.New("your-api-key")
calcTool := calculator.New()

// Create an agent
agent := agents.NewMRKLAgent(llm, []tools.Tool{searchTool, calcTool})
executor := agents.NewExecutor(agent)

// Run the agent
result, err := executor.Call(ctx, map[string]any{
	"input": "What's the current population of Tokyo multiplied by 2?",
})

Memory and Conversation

Maintain conversation context across multiple interactions:

import (
	"github.com/iohub/langchaingo/memory"
	"github.com/iohub/langchaingo/chains"
)

// Create memory
memory := memory.NewConversationBuffer()

// Create a conversation chain
chain := chains.NewConversation(llm, memory)

// Have a conversation
chains.Run(ctx, chain, "Hello, my name is Alice")
chains.Run(ctx, chain, "What's my name?") // Will remember "Alice"

Advanced Features

Streaming responses:

stream, err := llm.GenerateContentStream(ctx, messages)
for stream.Next() {
	chunk := stream.Value()
	fmt.Print(chunk.Choices[0].Content)
}

Function calling:

tools := []llms.Tool{
	{
		Type: "function",
		Function: &llms.FunctionDefinition{
			Name: "get_weather",
			Parameters: map[string]any{
				"type": "object",
				"properties": map[string]any{
					"location": map[string]any{"type": "string"},
				},
			},
		},
	},
}

content, err := llm.GenerateContent(ctx, messages, llms.WithTools(tools))

Multi-modal inputs (text and images):

parts := []llms.ContentPart{
	llms.TextPart("What's in this image?"),
	llms.ImagePart("data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQ..."),
}
content, err := llm.GenerateContent(ctx, []llms.MessageContent{
	{Role: llms.ChatMessageTypeHuman, Parts: parts},
})

Configuration and Environment

Most providers require API keys set as environment variables:

export OPENAI_API_KEY="your-openai-key"
export ANTHROPIC_API_KEY="your-anthropic-key"
export GOOGLE_API_KEY="your-google-key"
export HUGGINGFACEHUB_API_TOKEN="your-hf-token"

Error Handling

LangchainGo provides standardized error handling:

import "github.com/iohub/langchaingo/llms"

if err != nil {
	if llms.IsAuthenticationError(err) {
		log.Fatal("Invalid API key")
	}
	if llms.IsRateLimitError(err) {
		log.Println("Rate limited, retrying...")
	}
}

Testing

LangchainGo includes comprehensive testing utilities including HTTP record/replay for internal tests. The httprr package provides deterministic testing of HTTP interactions:

import "github.com/iohub/langchaingo/internal/httprr"

func TestMyFunction(t *testing.T) {
	rr := httprr.OpenForTest(t, http.DefaultTransport)
	defer rr.Close()

	client := rr.Client()
	// Use client for HTTP requests - they'll be recorded/replayed for deterministic testing
}

Examples

See the examples/ directory for complete working examples including:

• Basic LLM usage
• RAG (Retrieval Augmented Generation)
• Agent workflows
• Vector database integration
• Multi-modal applications
• Streaming responses
• Function calling

Contributing

LangchainGo welcomes contributions! The project follows Go best practices and includes comprehensive testing, linting, and documentation standards.

See CONTRIBUTING.md for detailed guidelines.