Comparisons / LangChain vs Rasa
LangChain vs Rasa: Which Agent Framework to Use?
LangChain langchain is the most popular agent framework. Rasa rasa is an open-source framework for building conversational ai — chatbots and virtual assistants. Here is how they compare — and what the same patterns look like in plain Python.
By the numbers
LangChain
132.3k
21.8k
Python
MIT
2022-10-17
Harrison Chase
Sequoia Capital, Benchmark
$25M Series A (2023), $25M Series B (2024)
3.5M
LangSmith (observability), LangServe (deployment)
Yes
Used by: Notion, Elastic, Instacart
github.com/langchain-ai/langchain →Rasa
21.1k
4.9k
Python
Apache-2.0
2016-10-14
Rasa Technologies
Rasa Pro / Rasa Cloud
Yes
GitHub stats as of April 2026. Stars indicate community interest, not necessarily quality or fit for your use case.
| Concept | LangChain | Rasa | Plain Python |
|---|---|---|---|
| Agent | AgentExecutor with LLMChain, PromptTemplate, OutputParser | Rasa agent with NLU pipeline, dialogue policies, and action server | A function that POSTs to /chat/completions and returns the response |
| Tools | @tool decorator, StructuredTool, BaseTool class hierarchy | Custom actions running on a separate action server via HTTP | A dict of callables: tools = {"add": lambda a, b: a + b} |
| Agent Loop | AgentExecutor.invoke() with internal iteration | — | A while loop: call LLM, check for tool_calls, execute, repeat |
| Conversation | ConversationBufferMemory, ConversationSummaryMemory | — | A messages list that persists outside the function |
| State | LangGraph state channels with typed reducers | — | A dict updated inside the loop: state["turns"] += 1 |
| Memory | VectorStoreRetrieverMemory, ConversationEntityMemory | — | A dict injected into the system prompt, saved via a remember() tool |
| Guardrails | OutputParser, PydanticOutputParser, custom validators | — | Two lists of lambda rules checked before and after the LLM call |
| NLU | — | NLU pipeline: tokenizer, featurizer, intent classifier, entity extractor | An LLM call with a prompt: "Classify this message's intent: {message}" |
| Dialogue | — | Stories/Rules YAML + dialogue policies for conversation flow | A state machine: if intent == 'greet': state = 'greeting'; respond() |
| Slots | — | Typed slots for tracking entities and state across turns | A dict updated during conversation: slots = {"order_id": "123"} |
| CALM | — | LLM for understanding + deterministic Flows for business logic | LLM parses user intent, if/else routes to the right handler function |
What both do in plain Python
Every concept in the table above — agent, tools, loop, memory, state — maps to a handful of Python primitives: a function, a dict, a list, and a while loop. Both LangChain and Rasa wrap these primitives in their own class hierarchies and APIs. The underlying pattern is the same ~60 lines of code. The difference is how much ceremony each framework adds on top.
When to use LangChain
LangChain adds value when you need production integrations (vector stores, specific LLM providers, deployment tooling). But if you want to understand what's happening — or your use case is straightforward — the plain Python version is easier to debug, modify, and reason about.
What LangChain does
LangChain provides a unifying interface across LLM providers, a class hierarchy for tools and memory, and orchestration via AgentExecutor and LangGraph. The core value proposition is interchangeable components: swap OpenAI for Anthropic by changing one class, plug in a vector store for retrieval, add memory without rewriting your loop. It also ships with dozens of integrations — document loaders, text splitters, embedding models, vector stores — that save you from writing boilerplate HTTP calls. For teams that need to compose many integrations quickly, this catalog is genuinely useful. The tradeoff is that you inherit a large dependency tree and a set of abstractions that sit between you and the actual API calls.
The plain Python equivalent
Every LangChain abstraction maps to a small piece of plain Python. AgentExecutor is a while loop that calls the LLM, checks for tool_calls in the response, executes the matching function from a tools dict, appends the result to a messages array, and repeats. Memory is a dict you inject into the system prompt. Output parsing is a function that validates the LLM's response before returning it. The entire agent — tool dispatch, conversation history, state tracking, guardrails — fits in about 60 lines of Python. No base classes, no decorators, no chain composition. Just a function, a dict, a list, and a loop. When something breaks, you read your 60 lines instead of navigating a class hierarchy.
When to use Rasa
Rasa is purpose-built for production conversational AI with enterprise requirements — on-premise deployment, regulatory compliance, deterministic business logic. For general-purpose agents or simple chatbots, an LLM with a system prompt and a few tools is faster to build and more flexible.
What Rasa does
Rasa provides a complete framework for building conversational AI systems. The traditional stack includes an NLU pipeline (intent classification and entity extraction), dialogue management (stories and rules that define conversation flows), and an action server for custom business logic. The newer CALM architecture separates language understanding (handled by LLMs) from business logic (handled by deterministic Flows), giving you LLM fluency without sacrificing reliability. Rasa focuses on enterprise requirements: on-premise deployment, data privacy, regulatory compliance, and deterministic behavior for critical business flows. You define your domain in YAML — intents, entities, slots, responses, actions — and Rasa trains a model that handles the conversation lifecycle. The framework is battle-tested in production across banking, telecom, and healthcare.
The plain Python equivalent
Intent classification is one LLM call: send the user's message with a prompt asking for the intent and entities, parse the JSON response. Dialogue management is a state machine — a dict tracking the current state and a series of if/else branches routing to the next step. Custom actions are functions you call based on the classified intent. Slot filling is updating a dict as entities are extracted. The entire conversational agent — intent handling, state tracking, tool dispatch, response generation — fits in about 60 lines. The LLM handles the language understanding that Rasa's NLU pipeline was trained for, and your if/else logic handles the flows that Rasa's dialogue policies managed. No YAML domain files, no training pipeline, no action server.
Or build your own in 60 lines
Both LangChain and Rasa implement the same 8 patterns. An agent is a function. Tools are a dict. The loop is a while loop. The whole thing composes in ~60 lines of Python.
No framework. No dependencies. No opinions. Just the code.
Build it from scratch →