rasa-pro 3.13.0rc4__tar.gz → 3.13.1a2__tar.gz

{rasa_pro-3.13.0rc4 → rasa_pro-3.13.1a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.13.0rc4
+Version: 3.13.1a2
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH
@@ -81,7 +81,7 @@ Requires-Dist: pep440-version-utils (>=1.1.0,<1.2.0)
 Requires-Dist: pluggy (>=1.2.0,<2.0.0)
 Requires-Dist: portalocker (>=2.7.0,<3.0.0)
 Requires-Dist: prompt-toolkit (>=3.0.28,<3.0.29)
-Requires-Dist: protobuf (>=4.23.3,<4.25.4)
+Requires-Dist: protobuf (>=4.25.8,<4.26.0)
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.10,<2.10.0)
 Requires-Dist: pydot (>=1.4,<1.5)
@@ -115,7 +115,7 @@ Requires-Dist: scikit-learn (>=1.5.1,<1.6.0)
 Requires-Dist: scipy (>=1.13.1,<1.14.0)
 Requires-Dist: sentencepiece[sentencepiece] (>=0.1.99,<0.2.0) ; extra == "transformers" or extra == "full"
 Requires-Dist: sentry-sdk (>=2.8.0,<3)
-Requires-Dist: setuptools (>=70.0.0,<70.1.0)
+Requires-Dist: setuptools (>=78.1.1,<78.2.0)
 Requires-Dist: sklearn-crfsuite (>=0.3.6,<0.4.0)
 Requires-Dist: skops (>=0.10.0,<0.11.0)
 Requires-Dist: slack-sdk (>=3.27.1,<3.28.0)

{rasa_pro-3.13.0rc4 → rasa_pro-3.13.1a2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.13.0rc4"
+version = "3.13.1a2"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -166,9 +166,9 @@ SQLAlchemy = ">=2.0.41,<2.1.0"
 sklearn-crfsuite = "~0.3.6"
 psycopg2-binary = ">=2.9.10,<2.10.0"
 python-dateutil = "~2.8.2"
-protobuf = ">=4.23.3,< 4.25.4"
+protobuf = "~4.25.8"
 tensorflow_hub = "^0.13.0"
-setuptools = "~70.0.0"
+setuptools = "~78.1.1"
 ujson = ">=5.8,<6.0"
 regex = "~2024.7.24"
 sentry-sdk = ">=2.8.0,<3"
@@ -374,8 +374,6 @@ convention = "google"
 
 
 
-
-
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

rasa_pro-3.13.1a2/rasa/builder/README.md

@@ -0,0 +1,120 @@
+# Rasa Prompt-to-Bot Service
+
+A production-ready service that generates Rasa chatbots from natural language descriptions using LLMs.
+
+## Architecture
+
+The service follows functional programming principles with minimal use of classes:
+
+### Core Modules
+
+- **`config.py`** - Configuration management using module-level constants
+- **`exceptions.py`** - Custom exception hierarchy for error handling
+- **`models.py`** - Pydantic models for request/response validation
+- **`llm_service.py`** - LLM interactions (minimal class for state management)
+- **`validation_service.py`** - Project validation functions
+- **`training_service.py`** - Model training functions
+- **`project_generator.py`** - Project generation (class for bot files state)
+- **`service.py`** - Main orchestrating service (class for app state)
+- **`logging_utils.py`** - Thread-safe logging utilities
+- **`llm_context.py`** - Conversation context formatting
+- **`main.py`** - Application entry point
+
+### Utility Scripts
+
+- **`scrape_rasa_docs.py`** - Documentation scraping
+- **`create_openai_vector_store.py`** - Documentation indexing
+
+## Key Design Principles
+
+1. **Functional First**: Use functions for stateless operations
+2. **Minimal Classes**: Classes only when state management is needed
+3. **Configuration**: Environment variables with sensible defaults
+4. **Error Handling**: Structured exception hierarchy
+5. **Type Safety**: Full type annotations and Pydantic validation
+6. **Thread Safety**: Safe concurrent operations
+7. **Resource Management**: Proper cleanup and lifecycle handling
+
+## Usage
+
+### Running the Service
+
+```bash
+python rasa/builder/main.py
+```
+
+### Environment Configuration
+
+```bash
+# OpenAI Settings
+export OPENAI_MODEL="gpt-4.1-2025-04-14"
+export OPENAI_TEMPERATURE="0.7"
+export OPENAI_VECTOR_STORE_ID="vs_xxxxx"
+export OPENAI_TIMEOUT="30"
+
+# Server Settings
+export SERVER_HOST="0.0.0.0"
+export SERVER_PORT="5005"
+export MAX_RETRIES="5"
+export CORS_ORIGINS="http://localhost:3000,https://example.com"
+
+# Validation Settings
+export VALIDATION_FAIL_ON_WARNINGS="false"
+```
+
+### API Endpoints
+
+- `POST /api/prompt-to-bot` - Generate bot from description
+- `GET /api/bot-data` - Get current bot configuration
+- `PUT /api/bot-data` - Update bot configuration (SSE)
+- `POST /api/llm-builder` - LLM helper for bot development
+- `GET /` - Health check
+
+### Documentation Setup
+
+```bash
+# 1. Scrape Rasa documentation
+python rasa/builder/scrape_rasa_docs.py
+
+# 2. Create OpenAI vector store
+python rasa/builder/create_openai_vector_store.py
+```
+
+## Benefits of Functional Approach
+
+- **Simpler**: Easy to understand and reason about
+- **Testable**: Functions are easier to unit test
+- **Reusable**: Pure functions can be composed
+- **Maintainable**: Clear separation of concerns
+- **Performant**: No unnecessary object overhead
+- **Debuggable**: Clear call stacks and data flow
+
+## Error Handling
+
+The service uses a structured exception hierarchy:
+
+- `PromptToBotError` - Base exception
+- `ValidationError` - Project validation failures
+- `TrainingError` - Model training issues
+- `LLMGenerationError` - LLM API problems
+- `ProjectGenerationError` - Generation retry exhaustion
+- `AgentLoadError` - Agent loading failures
+
+## Logging
+
+Structured logging with context using `structlog`:
+
+```python
+structlogger.info("operation.success", key="value")
+structlogger.error("operation.failed", error=str(e))
+```
+
+## State Management
+
+Only classes that truly need state:
+
+1. **`LLMService`** - Caches schemas and manages OpenAI client
+2. **`ProjectGenerator`** - Maintains current bot files
+3. **`PromptToBotService`** - Manages Sanic app and agent state
+
+Everything else uses pure functions for maximum simplicity and testability.

rasa_pro-3.13.1a2/rasa/builder/config.py

@@ -0,0 +1,69 @@
+"""Configuration module for the prompt-to-bot service."""
+
+import os
+from typing import Any, Dict
+
+import importlib_resources
+
+from rasa.constants import PACKAGE_NAME
+from rasa.shared.utils.yaml import read_yaml, read_yaml_file
+
+# OpenAI Configuration
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4.1-2025-04-14")
+OPENAI_TEMPERATURE = float(os.getenv("OPENAI_TEMPERATURE", "0.7"))
+OPENAI_VECTOR_STORE_ID = os.getenv(
+    "OPENAI_VECTOR_STORE_ID", "vs_685123376e288191a005b6b144d3026f"
+)
+OPENAI_MAX_VECTOR_RESULTS = int(os.getenv("OPENAI_MAX_VECTOR_RESULTS", "10"))
+OPENAI_TIMEOUT = int(os.getenv("OPENAI_TIMEOUT", "30"))
+
+# Server Configuration
+SERVER_HOST = os.getenv("SERVER_HOST", "0.0.0.0")
+SERVER_PORT = int(os.getenv("SERVER_PORT", "5005"))
+MAX_RETRIES = int(os.getenv("MAX_RETRIES", "5"))
+MAX_LOG_ENTRIES = int(os.getenv("MAX_LOG_ENTRIES", "30"))
+
+# CORS Configuration
+_cors_origins_env = os.getenv("CORS_ORIGINS", "*")
+CORS_ORIGINS = _cors_origins_env.split(",") if _cors_origins_env != "*" else ["*"]
+
+# Validation Configuration
+VALIDATION_FAIL_ON_WARNINGS = (
+    os.getenv("VALIDATION_FAIL_ON_WARNINGS", "false").lower() == "true"
+)
+VALIDATION_MAX_HISTORY = None  # Could be configured if needed
+
+
+def get_default_config(assistant_id: str) -> Dict[str, Any]:
+    """Get default Rasa configuration."""
+    base_config = read_yaml_file(
+        str(
+            importlib_resources.files(PACKAGE_NAME).joinpath(
+                "cli/project_templates/default/config.yml"
+            )
+        )
+    )
+    base_config["assistant_id"] = assistant_id
+    return base_config
+
+
+def get_default_endpoints() -> Dict[str, Any]:
+    """Get default endpoints configuration."""
+    return read_yaml_file(
+        str(
+            importlib_resources.files(PACKAGE_NAME).joinpath(
+                "cli/project_templates/default/endpoints.yml"
+            )
+        )
+    )
+
+
+def get_default_credentials() -> Dict[str, Any]:
+    """Get default credentials configuration."""
+    default_credentials_yaml = """
+    studio_chat:
+      user_message_evt: "user_message"
+      bot_message_evt: "bot_message"
+      session_persistence: true
+    """
+    return read_yaml(default_credentials_yaml)

rasa_pro-3.13.1a2/rasa/builder/create_openai_vector_store.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""Script to create and populate OpenAI vector store with Rasa documentation."""
+
+import json
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+import openai
+import structlog
+
+structlogger = structlog.get_logger()
+
+# Configuration
+DOCS_DIR = "rasa_docs_md"
+FILE_IDS_FILE = "file_ids.json"
+MARKDOWN_TO_URL_FILE = "markdown_to_url.json"
+ASSISTANT_NAME = "Rasa Docs Assistant"
+
+
+def load_url_mapping() -> Dict[str, str]:
+    """Load the markdown filename to URL mapping."""
+    markdown_to_url_file = Path(MARKDOWN_TO_URL_FILE)
+
+    if not markdown_to_url_file.exists():
+        raise FileNotFoundError(
+            f"URL mapping file {markdown_to_url_file} not found. "
+            "Please run scrape_rasa_docs.py first."
+        )
+
+    with open(markdown_to_url_file, "r") as f:
+        return json.load(f)
+
+
+def get_markdown_files(docs_dir: str = DOCS_DIR) -> List[Path]:
+    """Get all markdown files in the docs directory."""
+    docs_path = Path(docs_dir)
+
+    if not docs_path.exists():
+        raise FileNotFoundError(f"Documentation directory {docs_dir} not found")
+
+    md_files = list(docs_path.glob("*.md"))
+    if not md_files:
+        raise FileNotFoundError(f"No markdown files found in {docs_dir}")
+
+    structlogger.info("vector_store.found_files", count=len(md_files))
+    return md_files
+
+
+def load_or_upload_files(client: openai.OpenAI) -> List[Dict[str, str]]:
+    """Load existing file IDs or upload files to OpenAI."""
+    file_ids_file = Path(FILE_IDS_FILE)
+
+    if file_ids_file.exists():
+        structlogger.info("vector_store.loading_existing_files")
+        with open(file_ids_file, "r") as f:
+            return json.load(f)
+
+    return upload_files(client)
+
+
+def upload_files(client: openai.OpenAI) -> List[Dict[str, str]]:
+    """Upload markdown files to OpenAI."""
+    structlogger.info("vector_store.uploading_files")
+
+    md_files = get_markdown_files()
+    uploaded_files = []
+
+    for md_file in md_files:
+        try:
+            with open(md_file, "rb") as f:
+                uploaded = client.files.create(file=f, purpose="assistants")
+
+            file_info = {"file_id": uploaded.id, "file_name": md_file.name}
+            uploaded_files.append(file_info)
+
+            structlogger.info(
+                "vector_store.file_uploaded",
+                file_name=md_file.name,
+                file_id=uploaded.id,
+            )
+
+        except Exception as e:
+            structlogger.error(
+                "vector_store.upload_failed", file_name=md_file.name, error=str(e)
+            )
+            raise
+
+    # Save file IDs for future use
+    with open(FILE_IDS_FILE, "w") as f:
+        json.dump(uploaded_files, f, indent=2)
+
+    structlogger.info("vector_store.upload_complete", count=len(uploaded_files))
+    return uploaded_files
+
+
+def prepare_files_with_metadata(files: List[Dict[str, str]]) -> List[Dict[str, str]]:
+    """Prepare files with URL metadata."""
+    url_mapping = load_url_mapping()
+
+    files_with_metadata = []
+    for file_info in files:
+        file_name = file_info["file_name"]
+        url = url_mapping.get(file_name, "")
+
+        if not url:
+            structlogger.warning("vector_store.missing_url", file_name=file_name)
+
+        files_with_metadata.append(
+            {"file_id": file_info["file_id"], "file_name": file_name, "url": url}
+        )
+
+    return files_with_metadata
+
+
+def create_vector_store(
+    client: openai.OpenAI, files_with_metadata: List[Dict[str, str]]
+) -> str:
+    """Create vector store and add files."""
+    try:
+        # Create vector store
+        structlogger.info("vector_store.creating")
+        vector_store = client.vector_stores.create(name=ASSISTANT_NAME)
+
+        # Add files to vector store
+        for file_meta in files_with_metadata:
+            try:
+                client.vector_stores.files.create(
+                    vector_store_id=vector_store.id,
+                    file_id=file_meta["file_id"],
+                    attributes={"url": file_meta["url"]},
+                )
+
+                structlogger.info(
+                    "vector_store.file_added",
+                    file_name=file_meta["file_name"],
+                    url=file_meta["url"],
+                )
+
+            except Exception as e:
+                structlogger.error(
+                    "vector_store.file_add_failed",
+                    file_name=file_meta["file_name"],
+                    error=str(e),
+                )
+                # Continue with other files
+
+        structlogger.info(
+            "vector_store.created",
+            vector_store_id=vector_store.id,
+            files_count=len(files_with_metadata),
+        )
+
+        return vector_store.id
+
+    except Exception as e:
+        structlogger.error("vector_store.creation_failed", error=str(e))
+        raise
+
+
+def run_vector_store_creation() -> str:
+    """Run the complete vector store creation process."""
+    client = openai.OpenAI()
+
+    try:
+        # Load or upload files
+        files = load_or_upload_files(client)
+
+        # Prepare files with metadata
+        files_with_metadata = prepare_files_with_metadata(files)
+
+        # Create vector store
+        vector_store_id = create_vector_store(client, files_with_metadata)
+
+        print("\n🎉 Vector store created successfully!")
+        print(f"Vector store ID: {vector_store_id}")
+        print(f"Files processed: {len(files_with_metadata)}")
+
+        return vector_store_id
+
+    except Exception as e:
+        structlogger.error("vector_store.process_failed", error=str(e))
+        print(f"\n❌ Vector store creation failed: {e}")
+        raise
+
+
+def setup_logging():
+    """Setup basic logging."""
+    import logging.config
+
+    logging_config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "standard": {"format": "%(asctime)s [%(levelname)s] %(name)s: %(message)s"},
+        },
+        "handlers": {
+            "default": {
+                "level": "INFO",
+                "formatter": "standard",
+                "class": "logging.StreamHandler",
+            },
+        },
+        "loggers": {"": {"handlers": ["default"], "level": "INFO", "propagate": False}},
+    }
+
+    logging.config.dictConfig(logging_config)
+
+
+def main():
+    """Main entry point for the script."""
+    setup_logging()
+
+    try:
+        run_vector_store_creation()
+        return 0
+
+    except KeyboardInterrupt:
+        print("\n⏹️ Process interrupted by user")
+        return 1
+
+    except Exception as e:
+        print(f"\n💥 Unexpected error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

rasa_pro-3.13.1a2/rasa/builder/exceptions.py

@@ -0,0 +1,49 @@
+"""Custom exceptions for the prompt-to-bot service."""
+
+from typing import Any, Optional
+
+
+class PromptToBotError(Exception):
+    """Base exception for prompt-to-bot service."""
+
+    pass
+
+
+class ValidationError(PromptToBotError):
+    """Raised when Rasa project validation fails."""
+
+    def __init__(self, message: str, validation_logs: Optional[Any] = None):
+        super().__init__(message)
+        self.validation_logs = validation_logs
+
+
+class TrainingError(PromptToBotError):
+    """Raised when model training fails."""
+
+    pass
+
+
+class LLMGenerationError(PromptToBotError):
+    """Raised when LLM generation fails."""
+
+    pass
+
+
+class SchemaValidationError(PromptToBotError):
+    """Raised when schema validation fails."""
+
+    pass
+
+
+class AgentLoadError(PromptToBotError):
+    """Raised when agent loading fails."""
+
+    pass
+
+
+class ProjectGenerationError(PromptToBotError):
+    """Raised when project generation fails after retries."""
+
+    def __init__(self, message: str, attempts: int):
+        super().__init__(f"{message} (failed after {attempts} attempts)")
+        self.attempts = attempts

rasa_pro-3.13.1a2/rasa/builder/llm-helper-schema.json

@@ -0,0 +1,69 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "content_blocks": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          {
+            "type": "object",
+            "required": ["type", "text"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["text"]
+              },
+              "text": {
+                "type": "string"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["type", "text"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["link"]
+              },
+              "text": {
+                "type": "string",
+                "format": "uri"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["type", "file", "content"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["file"]
+              },
+              "file": {
+                "type": "string"
+              },
+              "content": {
+                "type": "string"
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["type", "text"],
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": ["code"]
+              },
+              "text": {
+                "type": "string"
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+}

rasa_pro-3.13.1a2/rasa/builder/llm_context.py

@@ -0,0 +1,81 @@
+import json
+from typing import Optional
+
+from rasa.shared.core.constants import DEFAULT_SLOT_NAMES
+from rasa.shared.core.events import (
+    ActionExecuted,
+    BotUttered,
+    FlowCompleted,
+    FlowStarted,
+    SlotSet,
+    UserUttered,
+)
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+def tracker_as_llm_context(tracker: Optional[DialogueStateTracker]) -> str:
+    """Convert a tracker to a string that can be used as context for the LLM."""
+    if not tracker or not tracker.events:
+        return "No conversation history available."
+
+    context_parts = []
+    current_turn = []
+
+    for event in tracker.events:
+        if isinstance(event, UserUttered):
+            if current_turn:
+                context_parts.append(" | ".join(current_turn))
+                current_turn = []
+            current_turn.append(f"User: {event.text}")
+            if event.intent:
+                current_turn.append(f"Intent: {event.intent.get('name')}")
+            if event.entities:
+                current_turn.append(
+                    f"Entities: {[e.get('entity') for e in event.entities]}"
+                )
+            if event.commands:
+                current_turn.append(
+                    f"Commands: {[cmd.get('name') for cmd in event.commands]}"
+                )
+
+        elif isinstance(event, BotUttered):
+            if event.text:
+                current_turn.append(f"Bot: {event.text}")
+
+        elif isinstance(event, ActionExecuted):
+            current_turn.append(f"Action: {event.action_name}")
+            if event.confidence:
+                current_turn.append(f"Confidence: {event.confidence:.2f}")
+
+        elif isinstance(event, SlotSet) and event.key not in DEFAULT_SLOT_NAMES:
+            current_turn.append(f"Slot Set: {event.key}={event.value}")
+
+        elif isinstance(event, FlowStarted):
+            current_turn.append(f"# Flow Started: {event.flow_id}")
+
+        elif isinstance(event, FlowCompleted):
+            current_turn.append(f"# Flow Completed: {event.flow_id}")
+
+    if current_turn:
+        context_parts.append(" | ".join(current_turn))
+
+    # Add final state information
+    context_parts.append("\nCurrent State:")
+    context_parts.append(f"Latest Message: {tracker.latest_message.text or '-'}")
+
+    # Add active flows from stack
+    if tracker.active_flow:
+        context_parts.append(f"Active Flow: {tracker.active_flow}")
+    if tracker.stack:
+        context_parts.append(f"Flow Stack: {json.dumps(tracker.stack.as_dict())}")
+
+    # Add slot values that are not None
+    non_empty_slots = {
+        k: str(v.value)
+        for k, v in tracker.slots.items()
+        if v is not None and k not in DEFAULT_SLOT_NAMES
+    }
+    if non_empty_slots:
+        context_parts.append(f"Slots: {json.dumps(non_empty_slots)}")
+
+    return "\n".join(context_parts)