LangChain Go

LangChain Go is the Go language implementation of LangChain, designed for building applications with Large Language Models (LLMs) through composability.

To get started, you can explore the official documentation site or the API reference on pkg.go.dev. For practical implementations, refer to the ./examples directory in the repository.

LangChainGo is organized into several core functional modules:

• Model I/O: Includes LLMs, Chat Models, Embeddings, and Prompts.
• Data Connection: Includes Document loaders, vector stores, text splitters, and retrievers.
• Chains: Sequences of calls and end-to-end applications.
• Memory: State persistence and conversation management.
• Agents: Decision-making and autonomous behavior.

LangChainGo provides several memory strategies to manage conversation context:

• Buffer Memory: Stores all conversation messages in a simple buffer. Best for short conversations requiring complete history.
• Window Buffer Memory: Maintains a sliding window of recent messages. Useful for limiting context length while preserving recent history.
• Token Buffer Memory: Manages memory based on token count rather than message count. Provides precise control over context size for LLM token limits.
• Summary Memory: Automatically summarizes older conversation history while keeping recent messages intact to balance context preservation and efficiency.
• Chat Message History: A lower-level interface for managing individual chat messages, suitable for custom memory implementations.

LangChainGo is designed for modular adoption. You do not need to import the entire framework. You can use specific packages based on your requirements:

• LLM clients: Use the llms package.
• Prompt templating: Add the prompts package.
• Conversational state: Include the memory package.
• Autonomous agents: Combine agents, tools, and chains packages.

Working with language models in langchaingo typically follows a three-step workflow:

1. Construct Input: Use the prompts package to build the input for the model.
2. Send Input: Use the llm (or model) package to send the constructed input to the language model.
3. Extract Output: Use the output_parser package to parse and extract structured information from the model's response.

LangChainGo follows Go-idiomatic patterns for execution and reliability:

• Context propagation: All operations require context.Context to support cancellation and timeouts.
• Error handling: Uses explicit error handling with typed errors to distinguish between different failure modes.
• Concurrency: Leverages Go's native goroutines and channels for concurrent operations.
• Resource management: Implements standard Go patterns for proper cleanup and resource management.

LangChainGo includes several built-in chain implementations for common patterns:

• LLM Chain: The simplest chain; calls an LLM with a prompt template.
• Sequential Chain: Chains multiple steps together, where each step's output feeds into the next.
• Map-Reduce Chain: Processes large documents by mapping operations across chunks and reducing results.
• Conversation Chain: Maintains conversation memory while processing new inputs.
• Retrieval QA Chain: Combines document retrieval with question answering capabilities.

LangChain Go provides a standard interface for interacting with various language models, including text-based Large Language Models (LLMs), Chat Models, and Text Embedding models.

All LLMs and Chat Models implement the llms.Model interface. This abstraction allows you to swap different model providers in your chains without modifying your application logic.

Key distinctions:

• LLMs: Use text-based input and output.
• Chat Models: Use message-based input and output.
• Text Embedding models: Used for converting text into vector representations.