Chatbot Development Frameworks: Skip Rasa, Build This Instead

The fastest way to identify whether a chatbot framework belongs to the previous era is to ask how it handles a request it was not explicitly trained for. An intent-based chatbot returns a fallback or confusion response and asks the user to rephrase. An LLM-powered chatbot reasons about the request, retrieves relevant context, and produces a response. The engineering implications of this distinction are substantial enough that the choice of framework, made before the first line of code, determines whether the resulting chatbot can be extended into a production-grade conversational agent or will require a complete rebuild in eighteen months.

The institutional signal that the framework landscape has changed is not subtle. Microsoft announced the archival of its Bot Framework SDK in 2025, documenting that support will no longer be provided as of December 31, 2025, and directing teams to migrate to the Microsoft 365 Agents SDK. The market for intent-based, rule-governed chatbot frameworks has not grown. It has been superseded by LLM-first architectures.

This post maps the four main approaches to chatbot development in 2025, explains where each belongs, and makes the case for which architecture you should build on before your next engagement.

The four chatbot architecture approaches in 2025

It helps to be precise about what changed. Chatbot frameworks before 2023 were built around the assumption that intent classification and entity extraction were the hard problems. NLU pipelines like Rasa’s original open-source stack were genuinely useful because they solved these problems reliably and cheaply without requiring a large language model. The assumption that intent classification is the hard problem no longer holds. LLMs classify intent as a side effect of generating responses. The hard problems in 2025 are orchestration, state management, tool integration, hallucination control, and compliance.

Rasa in 2025: not dead, but different

The headline on this blog is deliberately provocative. The more accurate statement is: if you are evaluating Rasa for a use case where the original intent-and-entity architecture was the right fit, and you have not reviewed what Rasa is now, you may be solving a problem that the current Rasa no longer has.

Rasa has made a decisive shift. CALM, the Conversational AI with Language Models framework, is now the core of Rasa’s architecture. CALM uses LLMs for natural language understanding and response generation while using deterministic flows for business logic execution. Rasa’s chatbot framework comparison blog explicitly positions the framework as model-agnostic: teams can integrate the LLM provider that fits today and switch later without rewriting core orchestration logic.

• CALM architecture: LLMs handle the language understanding layer. Deterministic flows define what business logic happens when. This prevents the hallucination-in-production problem that pure LLM agents face in regulated deployments
• Rasa’s 2026 predictions blog identifies the durable pattern as ‘language for understanding, deterministic flows for decisions, CALM-shaped even if named differently’, which is a significant convergence with LangGraph’s architecture of combining LLM agent nodes with deterministic graph edges
• On-premise deployment: Rasa supports full on-premises deployment, critical for financial services, government, and telecommunications sectors where regulatory standards make cloud-based chatbot infrastructure non-negotiable
• Rasa was recognized in the Forrester Wave for Conversational AI Platforms for Customer Service Q2 2026, evaluated among 14 leading enterprise platforms, confirming its position in the enterprise market despite the framework evolution
• Where Rasa is harder to work with: developer experience for teams not already in the Rasa ecosystem. The learning curve for CALM, the enterprise licensing model for production deployment, and the framework’s depth can create complexity that LangChain’s simpler agent loop avoids for teams that do not need Rasa’s enterprise conversation management features

LangChain for chatbot development: what IBM says

IBM describes LangChain as an open-source orchestration framework for building LLM-powered applications including chatbots, available in both Python and JavaScript libraries. IBM characterises LangChain as useful for developing simple AI agents with straightforward workflows, providing support for vector databases and utilities for memory that retain history and context.

For chatbot development specifically, LangChain provides:

• Conversation memory: LangChain’s memory modules maintain conversation history and can pass it to the LLM in a structured way, enabling context-aware multi-turn conversations without custom state management code
• RAG integration: LangChain’s retrieval chains connect the chatbot to vector stores, document corpora, and knowledge bases. This is the architecture that enables knowledge-grounded responses rather than purely parametric LLM output
• Tool use: chatbots built with LangChain can call APIs, query databases, run code, and take actions within the same conversation loop. This is the architecture upgrade from a question-answering chatbot to a task-completing conversational agent
• LLM flexibility: LangChain’s model abstraction layer allows the underlying LLM to be swapped without rewriting business logic. Teams can start with GPT-4o, migrate to Claude, or integrate a local Ollama model later with minimal code changes
• The limitation IBM identifies: LangChain’s built-in templates are helpful but not always necessary. For a straightforward chatbot that only needs a language model and a prompt, LangChain’s abstractions add overhead without proportionate value. IBM’s alternatives analysis notes that simple API calls to OpenAI or Anthropic are often sufficient for basic chatbot workflows

LangGraph for complex chatbot orchestration

When a chatbot needs more than a straightforward conversation loop, LangGraph is the architecture to reach for. LangChain’s documentation defines LangGraph as the low-level orchestration framework and runtime that LangChain is built on top of, suitable for complex workflows combining deterministic and agentic steps.

For chatbots, the use cases that push from LangChain to LangGraph are:

• Multi-step task completion: a customer service chatbot that needs to retrieve account data, verify identity, check inventory, and process a return in a single conversation requires stateful execution that survives mid-conversation interruptions. LangGraph’s durable state is designed for exactly this
• Human-in-the-loop: contact centre workflows where certain decisions require agent review before the chatbot proceeds. LangGraph’s checkpoint mechanism allows the agent to pause, surface the decision to a human, and resume with the approved action
• Multi-agent chatbot systems: a healthcare chatbot that routes triage questions to a clinical knowledge agent, billing questions to a financial agent, and appointment requests to a scheduling agent is a multi-agent system. LangGraph manages the routing, shared state, and coordination
• Auditable conversation trails: regulated industries require that the chatbot’s decision path be inspectable after the fact. LangGraph’s graph-based execution logs every node traversal and state transition, providing the evidence trail compliance requires

Botpress: the visual builder for LLM chatbots

Botpress occupies a middle position: more structured than a raw LangChain implementation, less opinionated than Rasa’s CALM, and designed for teams that want a visual development experience for LLM chatbot workflows without giving up the ability to write custom code when needed.

• Architecture: Botpress combines a visual flow builder for chatbot conversation design with LLM integration for natural language understanding and response generation. It supports multi-LLM selection across GPT-4o, Claude, Mistral, and others
• RAG and knowledge base: Botpress includes built-in knowledge base management for document ingestion and retrieval, which LangChain provides as a set of components the developer assembles. For teams that want knowledge base management with less assembly, Botpress’s built-in implementation is faster to start
• On-premise and cloud: Botpress supports both cloud-hosted and on-premise deployment, which is relevant for teams that need local deployment without operating the full LangChain infrastructure stack
• Limitation: Botpress’s customization ceiling is lower than LangChain or LangGraph. Teams that need complex multi-agent coordination, custom memory architectures, or deep tool integration will find Botpress’s abstractions more constraining than LangChain’s composable components

The architecture decision: which framework to choose

The choice of chatbot development framework in 2025 follows the same pattern as most AI architecture decisions: match the framework to the primary complexity in the system. The primary complexity for most production chatbots is one of four things.

• The conversational logic is simple but the integration is complex: use LangChain. Its tool use, memory, and RAG components handle the integration without requiring the agent to reason about complex state machines
• The conversational logic is complex, with multi-step workflows, human approvals, or multi-agent coordination: use LangGraph. Its durable state and checkpoint system are designed specifically for these patterns
• The team needs auditability, on-premise deployment, and hybrid LLM-plus-deterministic-flow architecture in a regulated industry: evaluate Rasa CALM. Its enterprise features and on-premise support are designed for this context
• The team wants visual development with LLM integration and built-in knowledge base management without assembling LangChain components: use Botpress. Accept its customization ceiling as a tradeoff for development speed
• The chatbot is simple and the team wants no framework overhead: call the LLM API directly. IBM explicitly notes that simple API calls are often sufficient for basic chatbot workflows that do not require complex orchestration

WebOsmotic’s chatbot development practice builds production LLM chatbots for clients in fintech, healthcare, and eCommerce. The framework recommendation comes after the architecture is defined, not before.

Frequently asked questions

Should I use Rasa or LangChain for chatbot development in 2025?

It depends on whether conversational flow control or LLM orchestration is the primary complexity. Rasa’s CALM architecture is well-suited to regulated industry deployments where chatbot behaviour must be deterministic and auditable, on-premise deployment is required, and the team needs enterprise conversation management features. IBM recommends LangChain for building LLM-powered chatbots with straightforward agent workflows, RAG integration, and tool use. LangGraph, within the LangChain ecosystem, handles complex multi-step workflows and human-in-the-loop patterns that Rasa’s CALM targets with a different architecture.

Is Rasa still relevant in 2025?

Yes, but it is a different product than the Rasa of 2021. Rasa’s CALM framework combines LLM-powered natural language understanding with deterministic flow management, directly addressing the hallucination and auditability problems that pure LLM agents face in regulated production deployments. Rasa was evaluated in the Forrester Wave for Conversational AI Platforms for Customer Service Q2 2026 among 14 leading enterprise platforms. It supports full on-premises deployment, which remains a hard requirement in financial services, government, and healthcare contexts where cloud-based chatbot infrastructure is non-negotiable.

What happened to the Microsoft Bot Framework?

Microsoft archived the Bot Framework SDK in 2025. Per Microsoft’s official documentation, the Bot Framework SDK is no longer updated or maintained, and support tickets will no longer be serviced as of December 31, 2025. Microsoft explicitly recommends migrating existing bots to the Microsoft 365 Agents SDK, which supports C#, JavaScript, and Python. This is the clearest institutional signal that the intent-based, rule-governed chatbot framework generation has been superseded by LLM-first agent architectures.

What is the difference between LangChain and LangGraph for chatbot development?

LangChain provides the higher-level orchestration abstractions for building chatbots: conversation memory, RAG retrieval chains, tool definitions, and model interfaces. IBM describes it as useful for simple AI agents with straightforward workflows. LangGraph is the lower-level runtime that LangChain is built on, providing durable state, checkpoint-based execution, and fine-grained control over the conversation graph. LangGraph is the right choice when the chatbot needs multi-step task completion that must survive interruptions, human-in-the-loop approval steps, or multi-agent routing. LangChain handles most standard chatbot use cases without needing to interact with LangGraph directly.

What is Botpress and when should I use it?

Botpress is a visual LLM chatbot development platform that combines a drag-and-drop flow builder with LLM integration, multi-model support, and built-in knowledge base management. It supports cloud and on-premise deployment. Botpress is the right choice when a team wants a visual development experience with LLM capabilities and built-in knowledge base management without assembling LangChain components from scratch. The tradeoff is a lower customization ceiling than LangChain: teams needing complex multi-agent coordination, custom memory architectures, or deep tool integration will outgrow Botpress’s abstractions.

What LLM chatbot architecture does WebOsmotic recommend for enterprise use cases?

WebOsmotic’s recommendation depends on the primary complexity in the specific use case. For production chatbots that need RAG, tool use, and straightforward conversation management, LangChain is the standard foundation. For chatbots with multi-step task workflows, human-in-the-loop requirements, or multi-agent routing, LangGraph provides the stateful execution primitives that LangChain alone cannot reliably deliver. For regulated industry deployments requiring on-premise hosting and hybrid LLM-plus-deterministic-flow architecture, Rasa CALM is worth evaluating alongside LangGraph. The framework is always chosen after the architecture is defined, not before.