Langflow

React 19 SPA using @xyflow/react canvas that enables users to visually compose AI workflows by dragging LangChain-backed components onto a canvas and connecting them via edges. The frontend maintains a graph state model that validates connections based on component input/output type compatibility before execution, preventing invalid topologies at design time. Connection validation occurs client-side through type introspection of component schemas, reducing round-trips to the backend.

Backend component system that dynamically loads and registers LangChain components (LLMs, retrievers, memory stores, tools) into a centralized registry accessible via API. Each component exposes a schema describing its input types (via Python type hints and Pydantic models) and output types, which the frontend uses for connection validation and UI form generation. The registry supports component bundles (e.g., NVIDIA, Docling) that can be installed as plugins, extending the available components without modifying core code.

Backend service for handling file uploads, storage, and document parsing. Supports multiple file formats (PDF, DOCX, PPTX, TXT, CSV, JSON, images) with format-specific parsers. Files are stored in a managed file system with metadata (upload time, user, size, format). Integrates with document loaders for RAG pipelines and supports batch file processing. Includes OCR capabilities for scanned PDFs and images.

Enables flows to be triggered by external webhooks, allowing external systems to invoke flows via HTTP POST. Webhooks are configured per flow with URL paths and optional authentication (API key, OAuth). When a webhook receives a request, it triggers the flow with the request payload as input and returns the flow output as the response. Supports webhook retries and event logging for debugging.

Built-in tracing system that captures detailed execution information including component execution order, input/output data, timing, and errors. Traces are stored in a database and accessible via the UI, showing a timeline of component execution with drill-down capability to inspect individual component runs. Integrates with external observability platforms (LangSmith, Datadog) for centralized monitoring. Includes performance metrics (latency, token usage, cost) per component and flow.

Implements the Model Context Protocol (MCP) standard, allowing flows to call tools exposed by MCP servers. MCP servers define tools with standardized schemas, and Langflow components can discover and invoke these tools without custom integration code. Supports multiple MCP server connections per flow, enabling access to diverse tool ecosystems (filesystem, web, databases, etc.). MCP integration abstracts away provider-specific tool calling differences.

Python SDK that enables developers to create, configure, and execute flows programmatically without the visual UI. Flows can be defined as Python code using a fluent API, with components instantiated and connected via method calls. The SDK supports local execution (in-process) and remote execution (via HTTP API). Enables integration of Langflow flows into larger Python applications and automation scripts.

FastAPI backend service that executes flows as directed acyclic graphs (DAGs) by topologically sorting components and executing them in dependency order. Execution is event-driven: each component emits events (start, progress, output, error) that are streamed back to the client via Server-Sent Events (SSE) or WebSocket, enabling real-time progress visualization. The engine maintains execution state (variable bindings, intermediate outputs) in memory during a single run, with optional persistence to a database for audit trails and replay.

Backend service that manages conversation memory across multiple message types (human, AI, tool, system) and persists them to a database-backed message store. Supports multiple memory strategies (buffer, summary, entity-based) that can be configured per flow. Messages are stored with metadata (timestamp, component source, execution ID) enabling retrieval and replay. The system integrates with LangChain's memory abstractions, allowing flows to maintain context across multiple invocations.

Pre-built flow patterns and components that enable rapid assembly of retrieval-augmented generation (RAG) pipelines. Includes document loaders (PDF, web, file), text splitters, embedding models, vector store connectors (Pinecone, Weaviate, Chroma, FAISS), and retriever components. Flows can chain document ingestion → embedding → storage → retrieval → LLM generation in a visual canvas. The system handles chunking strategy configuration, embedding model selection, and vector store initialization without code.

Framework for composing multi-agent systems where agents can call tools, delegate to other agents, and maintain shared state. Agents are implemented as components that wrap LangChain's AgentExecutor, with tool calling orchestrated via function-calling APIs (OpenAI, Anthropic, Ollama). The system manages agent state (memory, context, intermediate results) and enables agents to communicate via message passing. Flows can define agent hierarchies (supervisor agents delegating to worker agents) or peer-to-peer agent networks.

Developer API for creating custom components by writing Python classes that inherit from a Langflow base class and expose inputs/outputs via type-annotated methods. The framework automatically generates JSON schemas from Python type hints and Pydantic models, eliminating manual schema definition. Custom components are registered in the component registry and appear in the visual canvas alongside built-in components. Supports component bundles for packaging and distributing custom components.

Automatically generates REST API endpoints from flows, exposing them as HTTP POST endpoints that accept flow inputs and return outputs. Each flow can be deployed as a versioned API with automatic OpenAPI schema generation. The system supports multiple deployment targets (local, Docker, cloud platforms) and manages flow versioning, allowing multiple versions of a flow to coexist. Deployments API provides programmatic control over flow lifecycle (create, update, delete, activate).

Built-in web UI for testing flows interactively without deploying them. Users can override component parameters, execute the flow, and inspect intermediate outputs and execution logs in real-time. The playground supports chat-like interfaces for conversational flows and displays execution traces showing which components ran, their inputs/outputs, and timing. Supports batch testing with multiple input sets.

Enables conversational flows to accept voice input via speech-to-text (STT) and return voice output via text-to-speech (TTS). Integrates with multiple STT/TTS providers (OpenAI Whisper, Google Cloud Speech, Azure Speech Services, ElevenLabs). Voice mode is configured per flow and works with the chat interface, allowing users to speak queries and hear responses. Supports audio streaming for low-latency voice interactions.