langchain-hs v0.0.5
✨ Pure AST Pipelines & LangGraph in Haskell

Type-Safe AI Agents & Multi-Agent Graphs in Haskell

langchain-hs is a zero-unsafePerformIO, effect-polymorphic Haskell ecosystem built on pure GADT pipelines, state graphs, algebraic laws, Model Context Protocol (MCP), and production OpenTelemetry.

Get Started in 5 Min Explore 20 Components Prelude Cheat Sheet

Real Working Code: Ollama vs OpenAI

Switch between local inference (Ollama) and cloud APIs (OpenAI / OpenRouter) across all 20 components.

{-# LANGUAGE OverloadedStrings #-}
module Main where

import Control.Monad.Except (runExceptT)
import qualified Data.Text.IO as T
import Langchain.Prelude

main :: IO ()
main = do
  -- Connect to local Ollama instance (DeepSeek, Llama 3, Gemma, etc.)
  o <- newOllama "gemma3" defaultConfig
  
  let msg = [userMessage "Write a poem about functional programming in Haskell"]
  res <- runExceptT $ invoke o msg Nothing
  case res of
    Left err -> T.putStrLn $ errorMessage err
    Right m  -> T.putStrLn $ extractMessageText m
{-# LANGUAGE OverloadedStrings #-}
module Main where

import Control.Monad.Except (runExceptT)
import qualified Data.Text.IO as T
import Langchain.Prelude
import OpenAI.Common (defaultModelName, getOpenRouterModel)

main :: IO ()
main = do
  -- Connect to OpenAI or OpenRouter using environment API key
  o <- getOpenRouterModel defaultModelName
  
  let msg = [userMessage "Write a poem about functional programming in Haskell"]
  res <- runExceptT $ invoke o msg Nothing
  case res of
    Left err -> T.putStrLn $ errorMessage err
    Right m  -> T.putStrLn $ extractMessageText m

Complete Component Directory (20 Components)

Every component features dual Ollama/OpenAI examples, verified build targets, and complete Haskell signatures.

💬
Chat Models
Unified interface for model invocation, message types, options, and batch generation.
Ollama OpenAI Batch
🌊
Streaming
Real-time incremental token streaming and Conduit pipeline consumers.
streamChat Tokens
🏛️
Langchain Monad
Type-safe LangchainT transformer decoupled over custom environments and error handlers.
LangchainT ReaderT
🔧
Tools & Function Calling
Effect-polymorphic Haskell tools, JSON parameter schemas, and LLM tool execution.
Tool Schema
📋
Structured Outputs
Guaranteed JSON schema generation parsed into type-safe Aeson data structures.
FromJSON Parser
📚
RAG & Embeddings
Dense vector embeddings, cosine distance calculation, and document chunking.
Embeddings Cosine
🔍
Retrievers & Ensembles
Reciprocal Rank Fusion (RRF) combining BM25 keyword matching and vector stores.
BM25 RRF
🧠
Memory Systems
Buffer memories and persistent conversational history tracking across multi-turn sessions.
BufferMemory History
💡
Retrieval QA Chains
End-to-end question answering pipeline synthesizing relevant context and citations.
QA Chain Synthesis
🗺️
Map-Reduce Processing
Hierarchical summarization and chunk reduction over books, papers, and large corpora.
Map Reduce
🤖
ReAct Agent
Autonomous reasoning and acting loop with tool selection, execution, and observations.
ReAct Tools
🎯
Plan-and-Execute Agent
Decoupled macro-planner creating structured task DAGs with execution & replanning.
Planner Executor
🛡️
Guardrails & Safety
Pre- and post-execution filtering, PII redaction, and semantic policy moderation.
Guardrail Safety
⚡
Resilience & Retries
Exponential backoff retries, fallback providers, and circuit breaker patterns.
Fallback CircuitBreaker
📊
Observability & Tracing
Callbacks, execution timing, token metrics, and OpenTelemetry span exports.
OTel Callbacks
🔌
Model Context Protocol (MCP)
Stdio and HTTP JSON-RPC client connecting external tool and resource servers.
MCP JSON-RPC
🕸️
Stateful Graphs (StateGraph)
Cyclic workflows, pure state reducers, and checkpointed state machines.
LangGraph Cyclic
👥
Multi-Agent Systems
Supervisor routing, consensus debate, and multi-agent coordination.
Supervisor Debate
⏸️
Human-in-the-Loop (HITL)
Interrupt execution graphs for human approval, edit state, and resume seamlessly.
Interrupt Checkpointer
🔗
Runnables & AST Pipelines
First-class AST composition via pipe (|>>), parallel (&>&), and fallback (>>>#).
RunnableTree GADT
🛡️
Pure Zero-Dependency Core
langchain-hs-core defines AST pipelines (RunnableTree), multi-modal ContentBlock, and streaming without ANY HTTP dependencies.
🕸️
LangGraph in Haskell
Cyclic state machines with pure state reducers, STM TVar & SQLite checkpointers, Human-in-the-Loop interrupts, time-travel history replay, and Graphviz DOT export.
🔌
Model Context Protocol (MCP)
Native client supporting stdio and HTTP JSON-RPC 2.0 transports with automatic schema discovery and conversion to native Tool m instances.
👥
Advanced Multi-Agent Architectures
Plan-and-Execute, ReAct, Supervisor teams with capability routing, multi-agent debate with convergence checking, majority voting, and STM shared blackboards.
🔍
Hybrid Retrieval & RAG
Reciprocal Rank Fusion (RRF) combining BM25 keyword search and dense vector embeddings (SQLite-vec, InMemory, PgVector, Qdrant) with LLM rerankers.
📊
Production Observability
OpenTelemetry spans (withSpan), structured JSON logs, three-state Circuit Breaker, exponential backoff retries, connection pooling, and token cost calculation.
ESC
Press ↑ ↓ to navigate ESC to close