Chainlit Cookbook

Chainlit Cookbook demonstrates a decorator-driven architecture using @cl.on_message, @cl.on_chat_start, and @cl.on_file_upload handlers that bind Python functions to specific conversation lifecycle events. This pattern eliminates boilerplate by automatically routing user inputs, file uploads, and session initialization to decorated handlers, which then orchestrate LLM calls and state management. The framework manages WebSocket connections, message serialization, and frontend synchronization transparently.

Chainlit Cookbook examples demonstrate streaming LLM responses using cl.Message objects with token-by-token output, enabling real-time user feedback without waiting for full completion. The implementation uses async/await patterns with LLM streaming APIs (OpenAI, Anthropic) and Chainlit's built-in message streaming interface to push tokens to the frontend as they arrive. This pattern is shown across basic chat, agent systems, and real-time assistant examples.

Chainlit Cookbook demonstrates integration with OpenAI Assistants API, which provides managed conversation threads, built-in retrieval, code execution, and function calling. The implementation uses Chainlit decorators to wrap Assistants API calls, managing thread creation, message submission, and run polling. Unlike manual LLM orchestration, Assistants API handles memory, tool calling, and file retrieval automatically. Examples show basic assistants, assistants with file retrieval, and assistants with custom tools.

Chainlit Cookbook demonstrates integration with MCP (Multi-Capability Protocol) servers, which provide standardized tool definitions and execution interfaces. The implementation uses MCP clients to discover tools from MCP servers (Linear, Slack, GitHub, etc.), convert them to LLM function schemas, and execute them via tool calling. MCP enables dynamic tool discovery without hardcoding tool definitions, supporting both built-in and custom MCP servers.

Chainlit Cookbook provides templates for integrating Anthropic Claude models with native tool use (function calling), vision capabilities (image understanding), and streaming responses. The implementation uses Anthropic's Python SDK to call Claude models, define tool schemas in Anthropic format, and handle tool execution callbacks. Examples show Claude agents with tool calling, vision-based document analysis, and streaming chat responses.

Chainlit Cookbook provides deployment templates for AWS ECS using Docker containers, environment variable configuration, and reverse proxy setup. The implementation includes Dockerfile for containerizing Chainlit apps, docker-compose for local testing, and ECS task definitions for production deployment. Examples show how to configure Chainlit for cloud environments, manage secrets via environment variables, and set up load balancing.

Chainlit Cookbook demonstrates reverse proxy setup using nginx or HAProxy for production deployments, handling SSL/TLS termination, request routing, and load balancing across multiple Chainlit instances. The implementation includes configuration templates for common reverse proxy patterns, WebSocket support for Chainlit's real-time features, and health check configuration.

Chainlit Cookbook demonstrates BigQuery integration for agents that query large datasets, analyze data, and generate insights. The implementation uses LangChain agents with BigQuery tools, enabling natural language queries over structured data. Agents can explore schemas, write SQL, execute queries, and interpret results. The pattern supports multi-step data analysis where agents iteratively refine queries based on intermediate results.

Chainlit Cookbook provides templates for integrating vector databases (Chroma, Pinecone, Weaviate) with document Q&A systems using embeddings-based retrieval. The pattern involves loading documents, chunking them, generating embeddings, storing in a vector store, and retrieving relevant chunks via semantic similarity at query time. Examples show integration with LangChain retrievers and LlamaIndex document loaders, enabling RAG (Retrieval-Augmented Generation) pipelines where LLMs answer questions grounded in uploaded documents.

Chainlit Cookbook examples demonstrate function calling patterns where LLMs select and execute tools via schema-based function definitions. The implementation uses OpenAI function calling, Anthropic tool_use, and MCP (Multi-Capability Protocol) to define tool schemas, capture LLM tool selections, and dispatch to Python functions. The @cl.step decorator provides observability into tool execution, showing intermediate steps in the UI. This pattern enables agents to dynamically choose tools based on user intent.

Chainlit Cookbook demonstrates multi-modal interactions where messages can contain text, images, and files. The implementation uses @cl.on_file_upload to handle file ingestion and cl.Message with image elements to render visual content. Examples show vision model integration (GPT-4V, Claude 3 Vision) for image understanding, audio processing for real-time assistants, and document parsing for Q&A systems. The pattern supports mixed-modality conversations where users upload images/files and the LLM processes them alongside text.

Chainlit Cookbook provides templates demonstrating integration with LangChain agents, chains, and retrievers, as well as LlamaIndex document loaders, query engines, and RAG pipelines. The integration pattern uses Chainlit decorators to wrap LangChain/LlamaIndex components, enabling seamless orchestration of complex AI workflows. Examples show LangChain ReAct agents with tool calling, LlamaIndex multi-document Q&A, and hybrid approaches combining both frameworks.

Chainlit Cookbook provides templates for building custom React frontends and embedding custom UI elements (buttons, forms, charts, visualizations) in conversations. The implementation uses cl.Element and cl.Action to define interactive components, and custom React components can be embedded via Chainlit's plugin system. Examples show custom chat UIs, action buttons for user feedback, and data visualization components that respond to user interactions.

Chainlit Cookbook demonstrates real-time audio processing using OpenAI Realtime API and audio assistant patterns. The implementation handles audio input streaming, transcription, LLM processing, and audio output generation in a single conversational loop. The pattern uses WebSocket connections for low-latency audio streaming and integrates with speech-to-text and text-to-speech models. Examples show voice-based Q&A, audio transcription with follow-up chat, and real-time voice assistants.

Chainlit Cookbook demonstrates agent patterns using LangChain ReAct (Reasoning + Acting) and LangGraph for multi-step task decomposition. The implementation uses @cl.step decorators to visualize reasoning steps, tool calling for action execution, and memory management for maintaining context across steps. Agents dynamically select tools based on user intent, execute them, observe results, and iterate until task completion. Examples show BigQuery agents, document search agents, and general-purpose reasoning agents.

Chainlit Cookbook demonstrates conversation memory patterns using LangChain ConversationBufferMemory, LlamaIndex chat history, and Chainlit's built-in session management. The implementation stores conversation history, manages context windows to prevent token overflow, and retrieves relevant history for multi-turn interactions. Examples show memory persistence across sessions, context summarization for long conversations, and memory-augmented retrieval for grounding responses in prior exchanges.