RasaHQ/rasa

This system is an open-source conversational AI framework that enables the development, training, and deployment of chatbots and virtual assistants. It provides a comprehensive pipeline for natural language understanding, including intent classification, entity extraction, and dynamic response selection, alongside a dialogue management core that handles conversation state, forms, and fallback logic. The architecture supports extensibility through custom actions, external event brokers, and modular graph-based model training with caching and fine-tuning capabilities.

39 changes.

This period focused on the release of Rasa 3.6.21, which introduced a new minimum compatible model version and significant architectural changes. The codebase underwent a major refactoring to adopt a GraphComponent interface across core, NLU, and CLI modules, standardizing component lifecycles and execution. Concurrently, the project expanded its testing infrastructure and added new features such as the ResponseSelector and asynchronous NLG server examples.

36 changes.

This period focused on extracting core logic into a new rasa.shared package to centralize constants, exceptions, and data utilities, thereby reducing circular dependencies. Significant refactoring moved domain, conversation, NLU training data, and story parsing components into this shared layer, accompanied by the introduction of graph-based featurization and Hugging Face transformer integration. The work was heavily supported by comprehensive test coverage for the new shared modules and updated example bots.

31 changes.

This period focused on implementing a new graph-based model architecture to replace the linear pipeline, introducing components for training, storage, and execution via Dask. Extensive integration and unit tests were added to validate the new engine, schema validations, and external service interactions, alongside features for model recipes and conversation evaluation.

Introduces the \reminderbot\ example in the \examples/reminderbot\ directory, demonstrating how a bot can respond to external events and reminders. The example includes a new \callback\_server.py\ built on Sanic to handle bot responses, along with configuration files (\config.yml\, \domain.yml\, \credentials.yml\, \endpoints.yml\) and training data (\nlu.yml\, \rules.yml\) to support this functionality.

examples/reminderbot · high confidence

An empty \_\init\\_.py file was added to the examples directory, initializing it as a Python package.

examples · high confidence

The example concert bot now includes custom Rasa SDK actions in the actions module. Users can now search for concerts and venues, with results stored in slots, and view reviews for previously found items. Additionally, the bot can track user music preferences based on affirmative or negative responses.

examples/concertbot/actions · high confidence

Added several example files in the test classes directory to demonstrate how to implement custom Rasa graph components, including a dense BytePair featurizer, a sparse TF-IDF featurizer, a meta-fallback classifier, a meta-intent featurizer, a custom limit slot, and a generic component skeleton. These examples also include a standalone definition of the GraphComponent interface to illustrate the required methods for creating, loading, and processing data within the graph execution pipeline.

_data/test\classes · high confidence

New type stub files have been added for the aio-pika, Sanic, and Socket.IO libraries to improve static type checking. The stubs for aio-pika expose core connection, channel, and message classes, while the Sanic stubs define the Sanic app, Blueprint, and routing decorators. The Socket.IO stubs provide type definitions for the server, client, and various manager implementations, enabling better IDE support and type safety for code using these dependencies.

stubs · high confidence

The Binder environment now automatically downloads the spaCy English language model during the post-build phase, ensuring the model is available for use without requiring manual installation by the user.

binder · high confidence

This change introduces the core infrastructure for integrating Hugging Face transformers into Rasa's Natural Language Understanding pipeline. It adds a new module (\rasa.nlu.utils.hugging\_face\) containing a registry that maps model types (BERT, GPT, GPT2, XLNet, DistilBERT, RoBERTa, and CamemBERT) to their corresponding TensorFlow models, tokenizers, and default weights. Additionally, it provides specific pre- and post-processing functions to handle tokenization special tokens (such as CLS/SEP for BERT) and to derive sentence-level embeddings from sequence-level outputs, enabling users to leverage these pre-trained models for intent classification and entity extraction.

_rasa/nlu/utils/hugging\face · high confidence

The repository is initialized with essential configuration files and documentation. This includes a CHANGELOG managed by towncrier, a CONTRIBUTING guide for developers, a CODE\_OF\_CONDUCT, and a CODEOWNERS file to define team responsibilities. Build and CI/CD infrastructure is established via a Dockerfile, .dockerignore, and .pre-commit-config.yaml (integrating Black and docstring checks). Quality assurance is configured through .codeclimate.yml, .coveragerc, and .deepsource.toml, while .gitignore and .gitattributes standardize version control behavior.

(repo-wide) · high confidence

The NLU module is now distributed as a standalone package (\rasa.nlu\) with its own entry point, constants, and core components. This includes dedicated modules for model management (\model.py\), data conversion (\convert.py\), cloud storage persistence (\persistor.py\ supporting AWS, GCS, and Azure), and evaluation (\test.py\). The package exposes version information and provides utilities for running command-line NLU interactions (\run.py\).

rasa/nlu · high confidence

New validation schemas have been added for NLU training data (JSON and YAML formats) and response definitions. The NLU schema enforces structure for intents, entities, regex features, and lookup tables, while the response schema defines allowed keys for bot replies, including text, buttons, quick replies, and metadata. These changes ensure that training data and response configurations are validated against strict formats before processing.

_rasa/shared/nlu/training\data/schemas · high confidence

Users can now define how their model is trained and predicted through 'recipes' specified in the configuration file. This change introduces a base \Recipe\ interface and two implementations: the \default.v1\ recipe, which automatically generates a training and prediction graph from standard NLU pipeline and Core policy configurations, and the \graph.v1\ recipe, which allows users to explicitly define custom train and predict graph schemas. This provides a structured way to customize the model construction process, with the default recipe remaining the standard for typical Rasa projects.

rasa/engine/recipes · high confidence

Rasa now includes a new \rasa.utils.tensorflow\ package that centralizes TensorFlow-specific infrastructure. This adds custom Keras layers for sparse data handling and CRF decoding, a configurable data generator for batching and shuffling, and a checkpointing callback that saves model weights only when validation metrics improve. It also provides GPU/CPU environment configuration via environment variables and a safer serialization format for feature arrays using \safetensors\.

rasa/utils/tensorflow · high confidence

Rasa now includes a success markers system in the core evaluation module, allowing users to define and track specific points of interest within conversation sessions. This feature introduces a configurable marker registry with built-in condition markers (such as checking for specific actions or intents) and operator markers (including And, Or, Not, Sequence, and Occurrence) to compose complex evaluation criteria. The system also provides a MarkerTrackerLoader to efficiently retrieve conversation trackers from storage using strategies like loading all, sampling, or taking the first N, and includes a statistics module to compute and export summary metrics (such as session counts and preceding user turns) to CSV files for analysis.

rasa/core/evaluation · high confidence

The project now uses towncrier to generate release notes from Markdown newsfragments. Users will see a structured CHANGELOG with sections for features, improvements, bugfixes, documentation, and removals, generated via a new Jinja2 template and guided by the updated README instructions.

changelog · high confidence

A new \NLUMessageConverter\ component has been added to the graph components system to bridge the gap between user input and the NLU pipeline. This component converts incoming \UserMessage\ objects into internal \Message\ objects, extracting text, message IDs, and metadata, which enables the graph-based model to load and predict using standardized NLU message structures.

_rasa/graph\components/converters · high confidence

A new \ResponseSelector\ component is added to the NLU pipeline, allowing the system to rank and select candidate responses (such as utterances) based on user input. This component, implemented as a subclass of \DIETClassifier\, uses supervised embeddings to maximize similarity between user messages and candidate responses, providing ranked lists of potential replies and confidence scores. It requires a preceding featurizer in the pipeline and supports configuration for transformer layers, hidden sizes, and similarity metrics to enable dynamic response generation in conversations.

rasa/nlu/selectors · high confidence

The NLU pipeline now includes a dedicated \sparse\_featurizer\ package containing the base \SparseFeaturizer\ class and three concrete implementations: \CountVectorsFeaturizer\ (token counts using sklearn), \LexicalSyntacticFeaturizer\ (lexical/syntactic token features), and \RegexFeaturizer\ (regex and lookup table patterns). These components are registered as trainable message featurizers within the default recipe, enabling the model to extract sparse feature vectors from text, intents, and actions during training and inference.

_rasa/nlu/featurizers/sparse\featurizer · high confidence

The command-line interface now includes several new subcommands to improve data handling and model evaluation workflows. Users can use \rasa data\ to convert, split, and validate training files, including a new \rasa data validate stories\ command to check for inconsistencies in story files. A new \rasa evaluate markers\ command allows users to apply marker conditions to existing trackers for model evaluation. Additionally, \rasa export\ enables exporting conversations using an event broker, and \rasa telemetry\ provides commands to enable or disable anonymous usage reporting.

rasa/cli · high confidence

Developers can now spin up Kafka brokers in the test environment with various authentication and encryption setups, including SASL\_PLAIN and SASL\_SCRAM (SHA-256/512) with and without TLS. These configurations, provided as Docker Compose files and pre-generated certificates, allow engineers to test Rasa Open Source features against secure message broker setups locally.

_test\environments · high confidence

The NLU pipeline now includes several new intent classifiers: DIETClassifier (a transformer-based model for intent and entity extraction), LogisticRegressionClassifier (using scikit-learn), and RegexMessageHandler (for hardcoded intents via slash commands). The FallbackClassifier has been updated to support an \ambiguity\_threshold\ parameter, allowing it to trigger a fallback when the confidence difference between the top two intent predictions is below a specified value.

rasa/nlu/classifiers · high confidence

The \rasa/nlu/emulators\ package has been introduced to provide a standardized way for Rasa's Natural Language Understanding component to emulate the request and response formats of external conversational platforms. This location contributes the core \Emulator\ base class and specific implementations for Dialogflow, LUIS, wit.ai, and a default no-op emulator. These emulators transform Rasa's internal NLU data structures into the specific JSON schemas expected by these third-party services, enabling seamless integration and testing workflows that rely on external API formats.

rasa/nlu/emulators · high confidence

The \rasa/nlu/utils\ package now includes dedicated modules for core NLU operations: \pattern\_utils.py\ extracts and validates regex patterns from lookup tables and regex features, supporting configurable word boundaries; \bilou\_utils.py\ provides utilities to apply and manage BILOU entity tagging schemas on training data and messages; \spacy\_utils.py\ implements the \SpacyNLP\ component as a graph-based model loader that validates spaCy runtime compatibility and manages model fingerprinting; \mitie\utils.py\ similarly wraps the MITIE model loader with fingerprinting and graph component registration; and \\\init\\_.py\ exposes helper functions for writing JSON/text files and validating URLs.

rasa/nlu/utils · high confidence

Added a new example NLG server implementation in \examples/nlg\_server\ that uses the Sanic framework instead of the previous synchronous approach. The server exposes a \/nlg\ endpoint, accepts command-line arguments for port, worker count, and domain file path, and utilizes \DialogueStateTracker\ from \rasa.shared\ to process natural language generation requests asynchronously.

_examples/nlg\server · high confidence

The core featurization system has been replaced with a new graph-based architecture. This introduces a \MessageContainerForCoreFeaturization\ to deduplicate and cache NLU messages (intent, text, action) before featurization, and a new \SingleStateFeaturizer\ base class that handles the conversion of dialogue states into ML features using sparse matrices. The \TrackerFeaturizer\ base class now relies on this new structure, registering subclasses via a type-based registry and delegating state encoding to the \SingleStateFeaturizer\, resulting in a more modular and efficient training and prediction pipeline.

rasa/core/featurizers · high confidence

The tests\_deployment directory now provides the necessary configuration to run integration tests locally and on CI. This includes a README explaining the setup, an .env.example file with default credentials for Postgres and RabbitMQ, and Docker Compose files to spin up required external services: Redis, Postgres, RabbitMQ, Zookeeper, Kafka (with SASL/PLAIN authentication), and MongoDB.

_tests\deployment · high confidence

This change introduces the \rasa.core\ package, establishing the foundational structure for the Core module. It includes the main \Agent\ class for managing conversation models and interactions, a \MessageProcessor\ for handling message flow, and a \RasaNLUHttpInterpreter\ to enable parsing via an external NLU HTTP server. The package also defines core constants (such as default ports and policy priorities), custom exceptions (like \AgentNotReady\), and utilities for job scheduling and model exporting, effectively separating the Core logic from the NLU and shared components.

rasa/core · high confidence

The repository now includes a comprehensive suite of new scripts to automate the release lifecycle and documentation publishing. \scripts/release.py\ and \scripts/prepare\_nightly\_release.py\ handle version bumping for standard and nightly releases respectively, while \scripts/push\_docs\_to\_branch.sh\ manages the synchronization of documentation to versioned branches. Additional utilities include \scripts/publish\_gh\_release\_notes.py\ for generating GitHub release notes, \scripts/ping\_slack\_about\_package\_release.sh\ for Slack notifications, and \scripts/evaluate\_release\_tag.py\ to determine if documentation should be built for a specific tag. Linting and utility scripts such as \scripts/lint\_changelog\_files.sh\, \scripts/lint\_python\_docstrings.sh\, \scripts/poetry-version.sh\, \scripts/read\_tensorflow\_version.sh\, \scripts/download\_transformer\_model.py\, and \scripts/write\_keys\_file.sh\ are also added to support these workflows.

scripts · high confidence

The training data loading logic has been moved into the shared core module, introducing new \loading.py\ and \structures.py\ files to handle reading story files (YAML/Markdown) and managing story step structures. Additionally, a new visualization system has been added, including \visualization.py\ for generating story graphs and \visualization.html\ for rendering them in a browser, allowing users to visually inspect their training data.

_rasa/shared/core/training\data · high confidence

The reminder bot example now provides the actual Python code for its custom actions, located in the new \examples/reminderbot/actions/actions.py\ module. This file implements five specific actions: \ActionSetReminder\ to schedule reminders, \ActionReactToReminder\ to prompt users about tasks, \ActionTellID\ to display conversation IDs and trigger intents, \ActionWarnDry\ to notify users about plant care, and \ForgetReminders\ to cancel all active reminders. This change completes the example by adding the backend logic that was previously missing or stubbed.

examples/reminderbot/actions · high confidence

The core components for managing conversation state and domain configuration—specifically the Domain, Dialogue, Slot, SlotMapping, Event, and Tracker classes—have been relocated from the rasa.core package to the rasa.shared.core package. This refactoring centralizes the data models and logic required for domain validation, slot handling, and tracker state management, making them accessible to both the core training pipeline and external SDK components without creating circular dependencies.

rasa/shared/core · high confidence

This change introduces the new \rasa.shared\ package, which centralizes common resources previously scattered across the codebase. Users benefit from a more stable and consistent environment as key documentation URLs, default configuration paths (such as \config.yml\ and \domain.yml\), and training data format versions are now defined in \rasa.shared.constants\. Additionally, all core exception classes (like \RasaException\, \YamlSyntaxException\, and \ConnectionException\) and data handling utilities (for reading YAML/JSON training files) are now located in \rasa.shared\, ensuring that shared logic is independent of specific core or NLU implementations.

rasa/shared · high confidence

The \rasa.utils\ package has been introduced to centralize common utility functions. This change consolidates shared code into dedicated modules: \common.py\ for general utilities and configuration, \converter.py\ for training data format conversion, \endpoints.py\ for HTTP endpoint configuration and requests, \io.py\ for file and directory operations, \log\_utils.py\ for structured logging and anonymization, \plotting.py\ for visualization helpers, and \train\_utils.py\ for training-specific logic.

rasa/utils · high confidence

The core story and rule parsing logic has been relocated from the \rasa.core\ training data module to the \rasa.shared\ package. This change makes the \StoryReader\, \YAMLStoryReader\, and \StoryStepBuilder\ classes available for reuse by other components, such as the SDK or external tools, without requiring a dependency on the full core runtime.

_rasa/shared/core/training\_data/story\reader · high confidence

New converters have been added to the training data pipeline to automatically migrate legacy retrieval intent responses. When processing YAML story and domain files, these tools detect actions prefixed with 'respond\' and rename them to start with 'utter\', ensuring compatibility with the 2.0 format without requiring manual updates to training data.

rasa/core/training/converters · high confidence

NLU-related constants (such as intent, entity, and metadata keys) have been moved to \rasa.shared.nlu.constants\ to provide a single source of truth for shared data structures. Additionally, \NaturalLanguageInterpreter\ and \RegexInterpreter\ classes have been moved to \rasa.shared.nlu.interpreter\ and marked for removal, indicating they are legacy components no longer actively used in the core pipeline.

rasa/shared/nlu · high confidence

The core dialogue policies (MemoizationPolicy, RulePolicy, TEDPolicy, UnexpecTEDIntentPolicy) have been refactored to implement the new GraphComponent interface, replacing the previous Policy base class. This change introduces a new PolicyPrediction data structure for predictions and a DefaultPolicyPredictionEnsemble to handle combining predictions from multiple policies. The refactoring also includes updates to how policies are registered and instantiated via the DefaultV1Recipe, and modifies the ensemble logic to better handle prediction priorities and event combinations.

rasa/core/policies · high confidence

The dense featurizers in the NLU pipeline (SpaCy, Mitie, and ConveRT) now allow users to configure how token-level vectors are aggregated into a single sentence-level vector. By default, they use mean pooling, but the new \pooling\ configuration option lets you switch to max pooling. This change affects how the model interprets the overall semantic meaning of an utterance based on its constituent tokens.

_rasa/nlu/featurizers/dense\featurizer · high confidence

The entity extraction components in the NLU pipeline (CRFEntityExtractor, DucklingEntityExtractor, EntitySynonymMapper, MitieEntityExtractor, RegexEntityExtractor, and SpacyEntityExtractor) have been refactored to implement the GraphComponent interface. This change updates how these components are instantiated, trained, and loaded, integrating them into the new graph-based execution model while preserving their existing entity extraction behaviors.

rasa/nlu/extractors · high confidence

The event broker subsystem has been reorganized: a new \EventBroker\ base class in \rasa/core/brokers/broker.py\ now provides a unified factory method that catches connection errors and raises \ConnectionException\. The \PikaEventBroker\ has been migrated from the synchronous \pika\ library to the asynchronous \aio-pika\ library, switching to \SelectConnection\ for better concurrency and adding support for configurable exchange names. The \KafkaEventBroker\ has replaced the \kafka-python\ dependency with \confluent-kafka\, introducing support for \SASL\_SSL\ and \PLAINTEXT\ security protocols, SASL authentication parameters, and improved retry logic for publishing events.

rasa/core/brokers · high confidence

The training engine now uses a graph-based approach that includes a fingerprinting phase to determine which components can be restored from cache rather than retrained, significantly speeding up subsequent training runs. This change introduces support for model finetuning and adds training hooks that explicitly log whether a component is being trained or restored from the cache, providing clearer visibility into the training process.

rasa/engine/training · high confidence

The \rasa.engine.storage\ module now implements a new \ModelStorage\ backend for the graph-based architecture. This includes \LocalModelStorage\ which handles model archives by extracting them to local directories, specifically bypassing Windows long path name restrictions using the \\\\\?\\\ prefix. The storage system validates model compatibility by rejecting archives created with older Rasa versions (Rasa 2.x) via \UnsupportedModelVersionError\. Additionally, a \Resource\ class is introduced to manage persisted graph component outputs, supporting caching mechanisms that load and save resource data to and from the model storage.

rasa/engine/storage · high confidence

New components in the \rasa.graph\_components.providers\ package now handle the loading and provision of core training assets. \DomainProvider\ manages domain persistence and retrieval, while \DomainForCoreTrainingProvider\ supplies a pruned domain version that excludes irrelevant configuration (such as session settings and response text) to optimize core training. Additional providers streamline access to NLU training data (\NLUTrainingDataProvider\), story graphs (\StoryGraphProvider\), and training trackers (\TrainingTrackerProvider\), while specialized providers expose forms (\FormsProvider\), responses (\ResponsesProvider\), and rule-only data (\RuleOnlyDataProvider\) to support the new 3.0 architecture.

_rasa/graph\components/providers · high confidence

Rasa introduces a new internal graph-based architecture for model training and prediction, replacing the previous linear pipeline structure. This change brings a new \GraphSchema\ to define component dependencies, a \GraphComponent\ interface for all model parts, and a \DaskGraphRunner\ to execute these graphs. Users benefit from improved training performance through parallel execution via Dask, persistent caching of intermediate results to avoid re-computation, and stricter validation of model configurations to catch errors early.

rasa/engine · high confidence

The NLU tokenizers (Whitespace, Spacy, Mitie, and Jieba) have been refactored to inherit from the new \GraphComponent\ base class and register via \DefaultV1Recipe\. This migration updates the component lifecycle methods (\create\, \load\, \persist\) to align with the new execution graph, ensuring consistent initialization and model storage handling across all tokenizer implementations.

rasa/nlu/tokenizers · high confidence

The readers and writers for NLU training data formats (Rasa JSON, Rasa YAML, Dialogflow, LUIS, and WIT) have been relocated to the \rasa.shared.nlu.training\_data.formats\ package. This change centralizes the format handling logic, making these components available for reuse across different parts of the codebase without creating circular dependencies. Users importing these formats will need to update their import paths to reflect the new \rasa.shared\ location.

_rasa/shared/nlu/training\data/formats · high confidence

The NLU training data components (including \Message\, \TrainingData\, \Features\, and parsers) have been moved from \rasa.nlu\ to \rasa.shared.nlu.training\_data\. This change introduces \safetensors\ for saving and loading model features, replacing the previous \pickle\-based serialization to improve security and robustness. Additionally, entity parsing now validates JSON structures using \InvalidEntityFormatException\ and supports dynamic sparse feature allocation for incremental training.

_rasa/shared/nlu/training\data · high confidence

The NLU featurization module now introduces a new abstract \Featurizer\ base class that standardizes how sequence and sentence features are attached to messages. A key behavioral addition is the validation logic in \raise\_if\_featurizer\_configs\_are\_not\_compatible\, which now enforces that all featurizers in a pipeline must have unique aliases; if duplicate aliases are detected, the system raises an \InvalidConfigException\ to prevent configuration conflicts.

rasa/nlu/featurizers · high confidence

The story writing functionality has been reorganized into a new \rasa/shared/core/training\_data/story\_writer\ package. This introduces a base \StoryWriter\ abstract class and a concrete \YAMLStoryWriter\ implementation, which handle the conversion of story steps and rule steps into YAML format. The \YAMLStoryWriter\ supports exporting both standard stories and rules, manages checkpoints, and includes logic to filter specific events like \action\_listen\ and \action\_unlikely\_intent\ during the export process.

_rasa/shared/core/training\_data/story\writer · high confidence

The training data loading logic has been reorganized into a new, modular package at \rasa/shared/importers\. This introduces a core \TrainingDataImporter\ abstract base class that defines the standard interface for loading domain, NLU, and story data. Specific implementations include \RasaFileImporter\ for standard Rasa project structures and \MultiProjectImporter\ for combining data from multiple projects. A key behavioral addition is the \get\_conversation\_tests\ method, which allows the system to retrieve end-to-end conversation test stories separately from training stories, enabling dedicated testing workflows. Utility functions for loading data from file paths have also been extracted to \utils.py\ to support these importers.

rasa/shared/importers · high confidence

This change introduces a new \rasa/shared/utils\ package containing core utility modules (\cli\, \common\, \io\, \pykwalify\_extensions\, \validation\) that were previously scattered or part of other components. For users, this consolidates common functionality such as colored CLI output handling (with Windows colorama support), YAML/JSON file reading and writing, schema validation via pykwalify, and helper functions like \class\_from\_module\_path\ and \lazy\_property\. The \io\ module now uses \ruamel.yaml\ with \reader\_type=\['safe', 'rt'\]\ to preserve line number metadata for better error reporting, and the \validation\ module provides structured \YamlValidationException\ and \SchemaValidationError\ types with detailed line-number context. The \cli\ module adds colored print functions (\print\_success\, \print\_info\, etc.) and error exit handling. These utilities are now available as a shared, independent package for other Rasa components.

rasa/shared/utils · high confidence

Added \DefaultV1RecipeValidator\ and \FinetuningValidator\ to the graph components to enforce stricter validation rules during model training. The default recipe validator now checks the graph schema against training data and domain, issuing warnings for unused data (such as response examples without a ResponseSelector) or incompatible component combinations. The new finetuning validator ensures that fine-tuning is only permitted when the configuration (excluding epoch settings), domain structure, and NLU labels remain identical to the base model, raising errors if incompatible changes are detected or if the base model version is too old.

_rasa/graph\components/validators · high confidence

The \rasa/shared/utils/schemas\ module now includes dedicated schema definitions for validating Rasa configuration files. This adds a \domain.yml\ schema that enforces structure for intents, entities, actions, responses, slots (including slot mapping conditions with \active\_loop\ support), and forms; an \events.py\ schema that validates conversation event structures (such as user utterances, actions, and slot sets) with specific requirements for entity and value fields; a \model\_config.yml\ schema for pipeline and policy configurations; and a \stories.yml\ schema for validating story and rule steps. These changes provide stricter validation for user-defined configuration files, ensuring that domains, models, and conversation flows adhere to the expected structure.

rasa/shared/utils/schemas · high confidence

The CLI argument handling has been reorganized into a modular package under rasa/cli/arguments, introducing dedicated modules for each command (data, evaluate, export, interactive, run, shell, test, train, visualize, x) and a shared default\_arguments module for common parameters. This change adds new CLI capabilities including a data conversion command (rasa data convert) with format and language options, a data split command with training fraction and random seed controls, a data validator with a --fail-on-warnings flag, and a data migration command for upgrading domains to the 3.0 format. The evaluate command now supports marker extraction with configurable stats output. The run command gains network interface binding (--interface), configurable response/request timeouts, syslog logging support, and asymmetric JWT authentication options (--jwt-private-key). The test command introduces cross-validation for NLU, comparison modes with configurable runs and data exclusion percentages, and flags to report errors and successes. The train command adds dry-run validation, pre-training validation controls, and fine-tuning parameters. The interactive command now supports end-to-end story saving and configurable conversation IDs.

rasa/cli/arguments · high confidence

This entry covers the release of Rasa Open Source version 3.6.21. The update introduces a new minimum compatible model version of 3.6.21, meaning models trained with older versions of Rasa will no longer load and must be retrained. The release also includes a fix for retrieving conversation trackers from the HTTP API endpoint when dependent on query parameters, and resolves an issue with the \extractall\ function to ensure safer model extraction.

rasa · high confidence

The \rasa/core/channels\ package has been reorganized into a modular structure with a central \\_\init\\_.py\ that registers all built-in input channels (such as Slack, Facebook, Telegram, and the new Hangouts channel) into a \BUILTIN\_CHANNELS\ mapping. The core \channel.py\ module now defines the base \InputChannel\ and \OutputChannel\ classes, along with the \UserMessage\ data model and JWT decoding utilities. Several channel implementations have been updated or added, including a new Hangouts channel, a Callback channel for custom REST webhooks, and enhancements to existing channels like Bot Framework (JWT validation) and Facebook (metadata handling).

rasa/core/channels · high confidence

The Docker build system has been completely restructured to use a multi-stage build approach, separating base, builder, and runtime layers to improve efficiency and security. The base image now runs on Ubuntu 22.04 and includes the \rasa\ user for non-root execution. New dedicated images are provided for specific language models, including \spacy-en\, \spacy-de\, and \spacy-it\ (Italian), alongside the existing \mitie-en\ and \full\ variants. The build process now utilizes \docker-bake.hcl\ for configuration and pins \pip\ to version 22 and \wheel\ to \>0.38.0, while also adding support for ARM architectures in the builder stage.

docker · high confidence

The action execution logic has been restructured to use a new \LoopAction\ base class (in \rasa/core/actions/loops.py\), which standardizes the lifecycle of stateful actions like \FormAction\ and \TwoStageFallbackAction\. This change introduces a consistent activation, execution, and deactivation flow for these components, moving away from the previous ad-hoc implementations. Users will see this as a more robust and uniform handling of forms and fallback interactions, ensuring that activation and deactivation events are managed consistently across different loop-based actions.

rasa/core/actions · high confidence

The example action scripts for the knowledge base bot and rules bot have been moved from the root of their respective example folders into dedicated \actions/\ subdirectories. This change improves project structure by grouping related action implementations together, making the examples easier to navigate and maintain.

examples/knowledgebasebot/actions, examples/rules/actions · high confidence

The Natural Language Generator (NLG) logic has been reorganized into distinct modules: \generator.py\ (base class and factory), \response.py\ (templated generation), \callback.py\ (remote endpoint integration), and \interpolator.py\ (text replacement). This change introduces a dedicated interpolator that safely handles slot value injection into response templates, including support for nested structures and escaped placeholders. It also refines conditional response selection by extracting the \ResponseVariationFilter\ logic, ensuring more robust matching of response variations based on channel, action, and slot constraints. Users benefit from clearer separation of concerns, improved handling of complex template variables, and more reliable conditional response routing.

rasa/core/nlg · high confidence

The \rasa/core/training\ package has been reorganized into distinct modules to improve separation of concerns. A new \training.py\ module introduces \ActionFingerprint\ dataclasses to track which slots and active loops actions set during training, enabling better validation. The \interactive.py\ module has been updated to support interactive learning with Sanic-based server communication, including conversation ID management and domain retrieval. Additionally, a new \story\conflict.py\ module provides logic to detect and report structural conflicts in story graphs where different actions follow the same dialogue state. The main \\\init\\_.py\ now exposes \load\_data\ and \extract\_story\_graph\ functions that delegate to the shared core training data loaders and generators.

rasa/core/training · high confidence

The formbot example now uses a dedicated \ValidateRestaurantForm\ class inheriting from \FormValidationAction\ to handle slot validation. This change implements specific validation rules for cuisine (checking against a supported list), number of people (ensuring a positive integer), and outdoor seating (parsing 'out'/'in' keywords or boolean intent mappings), providing clearer feedback to users via new utterance responses when validation fails.

examples/formbot/actions · high confidence

Add integration test for slot extraction in account blocking; Added NLU test suite and fixtures; Added TensorFlow utility tests; Added comprehensive CLI integration tests; Added comprehensive test suite for the new graph-based engine; Added comprehensive test suites for core policies; Added comprehensive tests for the ResponseSelector component; Added integration test package structure; Added integration tests for ActionBotResponse with CallbackNaturalLanguageGenerator; Added integration tests for Kafka and Pika event brokers; Added integration tests for core infrastructure components; Added minimal test configuration for ResponseSelector; Added regression tests for slot retention, two-stage fallback, and domain merging; Added test coverage for shared utility functions; Added test endpoint configuration files for Redis, SQL, and model endpoints; Added tests for NLU message conversion; Added tests for NLU training data handling in shared module; Added tests for Natural Language Generator response selection logic; Added tests for YAML story reader slot handling and parsing; Added tests for YAMLStoryWriter functionality; Added tests for core training data structures and visualization; Added tests for default and graph recipe configurations; Added tests for event schema validation; Added tests for example bot training data validation; Added tests for graph component providers; Added tests for graph-based configuration validators; Added tests for interactive training and story conflict detection; Added tests for local model storage, resource caching, and metadata validation; Added tests for release tag evaluation logic; Added tests for the marker evaluation system; Added tests for the rasa.shared package structure and data utilities; Added tests for training engine caching, fingerprinting, and hooks; Added unit tests for NLU classifier components; Added unit tests for NLU emulator normalisation logic; Added unit tests for NLU entity extractors; Added unit tests for NLU utility components; Added unit tests for core action behaviors; Added unit tests for core channel integrations; Added unit tests for core featurizers; Added unit tests for core shared components; Added unit tests for the shared data importers; Added unit tests for utility modules; Established core test infrastructure and expanded unit test coverage; Initial test suite scaffolding and infrastructure.

This change introduces the foundational dependency manifests for the Rasa project, establishing the Python environment via \pyproject.toml\ and \poetry.lock\, and the documentation build environment via \docs/package.json\ and \docs/yarn.lock\. The Python dependencies pin the core application to version 3.6.21, specifying requirements such as \rasa-sdk\ (\~3.6.2), \tensorflow\ (via \tensorflow\_hub\ ^0.13.0), \aiohttp\ (\>=3.9.0), and \sanic\ (\~21.12), along with tooling like \black\, \mypy\, and \ruff\. The documentation dependencies configure Docusaurus (2.0.0-alpha.63) and related plugins for the static site generator, alongside development tools like \netlify-cli\ and \remark\ for linting.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 58.

• Code Health 90
• Architecture 99
• Maturity 59
• Readiness 53
• Security 50
• Domain Modelling 100

• 300 commits — 277 feature/other, 23 fixes

• (repo) — 89 commits
• (root) — 52 commits
• docs/docs — 52 commits
• rasa/core — 28 commits
• .github/workflows — 21 commits
• rasa/utils — 7 commits
• tests/integration_tests — 3 commits
• changelog/12579.doc.md — 2 commits
• data/test — 2 commits
• docs/themes — 2 commits
• rasa/nlu — 2 commits
• .github/poetry_version.txt — 1 commit
• changelog/12371.doc.md — 1 commit
• changelog/12492.misc.md — 1 commit
• changelog/12516.bug.md — 1 commit
• changelog/12516.bugfix.md — 1 commit
• changelog/12527.doc.md — 1 commit
• changelog/12543.improvement.md — 1 commit
• changelog/12560.improvement.md — 1 commit
• changelog/12581.doc.md — 1 commit

• fix: -mtrying to fix docker tagging
• fix: Fix 3.6.x build (#13068)
• fix: Fix OSS-413: Proper intents in interactive training
• fix: Fix docker-full build failure (#12895)
• fix: Fix link format
• fix: Fix poetry install errors (#12902)
• fix: Fix version of actions with sha (security) (#12548)
• fix: Merge branch '3.6.x' into ATO-1200-fix-structlog-BlockingIOError
• fix: Merge branch '3.6.x' into ATO-1419-fix-dnspython-dependency-ish-3.6.x
• fix: Merge pull request #12610 from RasaHQ/fix-docs-image
• fix: Merge pull request #12634 from RasaHQ/Fix-docker-image-building
• fix: Merge pull request #12661 from RasaHQ/ATO-1200-fix-structlog-BlockingIOError
• fix: Merge pull request #12737 from RasaHQ/ATO-1419-fix-dnspython-dependency-ish-3.6.x
• fix: Merge pull request #12814 from RasaHQ/ATO-1529-fix-domain-responses-key-error-3.6.x
• fix: Merge pull request #12898 from RasaHQ/ATO-1627-fix-roberto-workflow
• fix: Proper model downloading to fix flaky nlu featurizer tests (#12585)
• fix: [ATO-2122] Backport rasa export Kafka bugfix to 3.6.x (#13017)
• fix: [ENG-712] Fix dependency install failures on windows (#150)
• fix: fix img url in realtime-markers docs
• fix: fix install ddtrace step on windows
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

RasaHQ/rasa was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.