rasa-pro 3.13.1a15__tar.gz → 3.13.1a16__tar.gz

{rasa_pro-3.13.1a15 → rasa_pro-3.13.1a16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.13.1a15
+Version: 3.13.1a16
 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

{rasa_pro-3.13.1a15 → rasa_pro-3.13.1a16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.13.1a15"
+version = "3.13.1a16"
 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>",]
@@ -374,6 +374,7 @@ convention = "google"
 
 
 
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

{rasa_pro-3.13.1a15 → rasa_pro-3.13.1a16}/rasa/builder/exceptions.py

@@ -29,6 +29,12 @@ class LLMGenerationError(PromptToBotError):
     pass
 
 
+class DocumentRetrievalError(PromptToBotError):
+    """Raised when document retrieval fails."""
+
+    pass
+
+
 class SchemaValidationError(PromptToBotError):
     """Raised when schema validation fails."""
 

rasa_pro-3.13.1a16/rasa/builder/inkeep-rag-response-schema.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "content": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string"
+          },
+          "source": {
+            "type": "object",
+            "properties": {
+              "content": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string"
+                    },
+                    "media_type": {
+                      "type": "string"
+                    },
+                    "text": {
+                      "type": "string"
+                    },
+                    "data": {
+                      "type": "string"
+                    }
+                  }
+                }
+              },
+              "type": {
+                "type": "string"
+              },
+              "media_type": {
+                "type": "string"
+              },
+              "data": {
+                "type": "string"
+              }
+            }
+          },
+          "title": {
+            "type": "string"
+          },
+          "context": {
+            "type": "string"
+          },
+          "record_type": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  },
+  "required": ["content"]
+} 

rasa_pro-3.13.1a16/rasa/builder/inkeep_document_retrieval.py

@@ -0,0 +1,212 @@
+import asyncio
+import json
+import os
+from contextlib import asynccontextmanager
+from typing import List, Optional
+
+import importlib_resources
+import openai
+import structlog
+from openai.types.chat import ChatCompletion
+
+from rasa.builder.exceptions import DocumentRetrievalError
+from rasa.builder.models import Document
+from rasa.constants import PACKAGE_NAME
+from rasa.shared.utils.io import read_json_file
+
+INKEEP_API_KEY_ENV_VAR = "INKEEP_API_KEY"
+INKEEP_RAG_RESPONSE_SCHEMA_PATH = str(
+    importlib_resources.files(PACKAGE_NAME).joinpath(
+        "builder/inkeep-rag-response-schema.json"
+    )
+)
+
+INKEEP_DOCUMENT_RETRIEVAL_MODEL = "inkeep-rag"
+INKEEP_BASE_URL = "https://api.inkeep.com/v1/"
+
+structlogger = structlog.get_logger()
+
+
+class InKeepDocumentRetrieval:
+    """Handles the document retrieval from InKeep AI."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+    ):
+        self._client: Optional[openai.AsyncOpenAI] = None
+        self._rag_schema = read_json_file(INKEEP_RAG_RESPONSE_SCHEMA_PATH)
+        self._api_key = api_key or os.getenv(INKEEP_API_KEY_ENV_VAR)
+
+    async def retrieve_documents(
+        self, query: str, temperature: float = 0.0, timeout: float = 30.0
+    ) -> List[Document]:
+        """Retrieve relevant documents using InKeep AI based on the given query.
+
+        Args:
+            query: The search query
+            temperature: Controls randomness in generation (0.0 for deterministic)
+            timeout: Timeout for the API call
+
+        Returns:
+            List of Document objects containing retrieved content
+
+        Raises:
+            LLMGenerationError: If the API call fails or returns invalid response
+        """
+        response = await self._call_inkeep_rag_api(
+            query=query,
+            temperature=temperature,
+            timeout=timeout,
+        )
+        documents = self._parse_documents_from_response(response)
+        return documents
+
+    async def _call_inkeep_rag_api(
+        self, query: str, temperature: float, timeout: float
+    ) -> ChatCompletion:
+        """Call InKeep AI RAG's API endpoint and return the response content.
+
+        Args:
+            query: The search query to send to InKeep
+            temperature: Controls randomness in generation (0.0 for deterministic)
+            timeout: Timeout for the API call
+
+        Returns:
+            The response content from InKeep AI. The response is made of the retrieved
+            documents.
+
+        Raises:
+            LLMGenerationError: If the API call fails or returns invalid response
+        """
+        request_params = {
+            "model": INKEEP_DOCUMENT_RETRIEVAL_MODEL,
+            "messages": [{"role": "user", "content": query}],
+            "temperature": temperature,
+            "timeout": timeout,
+            "response_format": {
+                "type": "json_schema",
+                "json_schema": self._rag_schema,
+            },
+        }
+        try:
+            async with self._get_client() as client:
+                response = await client.chat.completions.create(**request_params)
+
+                if not response.choices[0].message.content:
+                    structlogger.warning(
+                        "inkeep_document_retrieval.empty_response",
+                        event_info="InKeep AI returned an empty response. ",
+                        request_params=request_params,
+                        response_content=response.choices[0].message.content,
+                    )
+                    raise DocumentRetrievalError(
+                        "InKeep Document Retrieval: Empty response"
+                    )
+
+                return response
+
+        except openai.OpenAIError as e:
+            structlogger.error(
+                "inkeep_document_retrieval.api_error",
+                event_info="InKeep Document Retrieval: API error",
+                request_params=request_params,
+                error=e,
+            )
+            raise DocumentRetrievalError(f"InKeep Document Retrieval: API error: {e}")
+        except asyncio.TimeoutError as e:
+            structlogger.error(
+                "inkeep_document_retrieval.timeout_error",
+                event_info="InKeep Document Retrieval: Timeout error",
+                request_params=request_params,
+                error=e,
+            )
+            raise DocumentRetrievalError(f"InKeep AI request timed out: {e}")
+        except Exception as e:
+            structlogger.error(
+                "inkeep_document_retrieval.error",
+                event_info="InKeep Document Retrieval: Error",
+                request_params=request_params,
+                error=e,
+            )
+            raise DocumentRetrievalError(
+                f"InKeep Document Retrieval: Unexpected error: {e}"
+            )
+
+    @asynccontextmanager
+    async def _get_client(self):
+        """Get or create client that handles the API calls to InKeep AI."""
+        if self._client is None:
+            self._client = openai.AsyncOpenAI(
+                api_key=self._api_key,
+                base_url=INKEEP_BASE_URL,
+            )
+
+        try:
+            yield self._client
+        except Exception as e:
+            structlogger.error(
+                "inkeep_document_retrieval.client_error",
+                event_info="InKeep Document Retrieval: Client error",
+                error=str(e),
+            )
+            raise
+
+    def _parse_documents_from_response(
+        self, response: ChatCompletion
+    ) -> List[Document]:
+        """Parse the InKeep AI response into Document objects.
+
+        Args:
+            response: ChatCompletion response from InKeep AI's RAG model.
+
+        Returns:
+            List of Document objects
+        """
+        try:
+            content = response.choices[0].message.content
+            if not content:
+                return []
+
+            response_data = json.loads(content)
+            documents = []
+
+            for item in response_data.get("content", []):
+                try:
+                    document = Document.from_inkeep_rag_response(item)
+                    documents.append(document)
+                except Exception as e:
+                    structlogger.warning(
+                        "inkeep_document_retrieval.invalid_document_skipped",
+                        event_info=(
+                            "InKeep Document Retrieval: Invalid document structure "
+                            "skipped. Returning empty list for this item."
+                        ),
+                        error=str(e),
+                        item=item,
+                    )
+                    # Continue processing other items, skip this invalid one
+                    continue
+
+            return documents
+
+        except json.JSONDecodeError as e:
+            structlogger.warning(
+                "inkeep_document_retrieval.parse_response_failed",
+                event_info=(
+                    "InKeep Document Retrieval: Parse response failed. "
+                    "Returning empty list.",
+                ),
+                error=str(e),
+            )
+            return []
+        except Exception as e:
+            structlogger.error(
+                "inkeep_document_retrieval.parse_response_error",
+                event_info=(
+                    "InKeep Document Retrieval: Parse response error. "
+                    "Returning empty list.",
+                ),
+                error=str(e),
+            )
+            return []

{rasa_pro-3.13.1a15 → rasa_pro-3.13.1a16}/rasa/builder/llm_service.py

@@ -11,11 +11,13 @@ import importlib_resources
 import openai
 import structlog
 from jinja2 import Template
+from pydantic import ValidationError
 
 from rasa.builder import config
 from rasa.builder.exceptions import LLMGenerationError
+from rasa.builder.inkeep_document_retrieval import InKeepDocumentRetrieval
 from rasa.builder.llm_context import tracker_as_llm_context
-from rasa.builder.models import LLMBuilderContext
+from rasa.builder.models import Document, LLMBuilderContext, LLMHelperResponse
 from rasa.constants import PACKAGE_NAME
 from rasa.shared.constants import DOMAIN_SCHEMA_FILE, RESPONSES_SCHEMA_FILE
 from rasa.shared.core.flows.yaml_flows_io import FLOWS_SCHEMA_FILE
@@ -135,7 +137,7 @@ class LLMService:
 
     async def generate_helper_response(
         self, messages: List[Dict[str, Any]]
-    ) -> Dict[str, Any]:
+    ) -> LLMHelperResponse:
         """Generate helper response using OpenAI."""
         self._prepare_schemas()
 
@@ -158,9 +160,11 @@ class LLMService:
                     raise LLMGenerationError("Empty response from LLM helper")
 
                 try:
-                    return json.loads(content)
+                    return LLMHelperResponse.model_validate_json(json.loads(content))
                 except json.JSONDecodeError as e:
                     raise LLMGenerationError(f"Invalid JSON from LLM helper: {e}")
+                except ValidationError as e:
+                    raise LLMGenerationError(f"Invalid JSON from LLM helper: {e}")
 
         except openai.OpenAIError as e:
             raise LLMGenerationError(f"OpenAI API error in helper: {e}")
@@ -169,27 +173,11 @@ class LLMService:
 
     async def search_documentation(
         self, query: str, max_results: Optional[int] = None
-    ) -> List[Dict[str, Any]]:
+    ) -> List[Document]:
         """Search documentation using OpenAI vector store."""
-        if max_results is None:
-            max_results = config.OPENAI_MAX_VECTOR_RESULTS
-
-        try:
-            async with self._get_client() as client:
-                results = await client.vector_stores.search(
-                    vector_store_id=config.OPENAI_VECTOR_STORE_ID,
-                    query=query,
-                    max_num_results=max_results,
-                    rewrite_query=True,
-                )
-
-                return results.data
-
-        except openai.OpenAIError as e:
-            structlogger.warning(
-                "llm.documentation_search_failed", error=str(e), query=query
-            )
-            return []
+        inkeep_document_retrieval = InKeepDocumentRetrieval()
+        documents = await inkeep_document_retrieval.retrieve_documents(query)
+        return documents
 
     @staticmethod
     def _format_chat_dump(messages: List[Dict[str, Any]]) -> str:
@@ -213,16 +201,15 @@ class LLMService:
         return result
 
     @staticmethod
-    def _format_documentation_results(results: List[Dict[str, Any]]) -> str:
+    def _format_documentation_results(results: List[Document]) -> str:
         """Format documentation search results."""
         if not results:
             return "<sources>No relevant documentation found.</sources>"
 
         formatted_results = ""
         for result in results:
-            formatted_result = f"<result url='{result.attributes.get('url', '')}'>"
-            for part in result.content:
-                formatted_result += f"<content>{part.text}</content>"
+            formatted_result = f"<result url='{result.url}'>"
+            formatted_result += f"<content>{result.content}</content>"
             formatted_results += formatted_result + "</result>"
 
         return f"<sources>{formatted_results}</sources>"

{rasa_pro-3.13.1a15 → rasa_pro-3.13.1a16}/rasa/builder/models.py

@@ -129,14 +129,6 @@ class LLMHelperResponse(BaseModel):
     content_blocks: List[Union[TextBlock, CodeBlock, FileBlock, LinkBlock]] = Field(...)
 
 
-class ApiResponse(BaseModel):
-    """Standard API response model."""
-
-    status: str = Field(...)
-    message: Optional[str] = Field(None)
-    data: Optional[Dict[str, Any]] = Field(None)
-
-
 class ApiErrorResponse(BaseModel):
     """API error response model."""
 
@@ -172,3 +164,62 @@ class TrainingResult(BaseModel):
     success: bool = Field(...)
     model_path: Optional[str] = Field(None)
     error: Optional[str] = Field(None)
+
+
+BotFiles = Dict[str, Optional[str]]
+
+
+class Document(BaseModel):
+    """Model for document retrieval results."""
+
+    content: str = Field(...)
+    url: Optional[str] = Field(None)
+    title: Optional[str] = Field(None)
+    metadata: Optional[Dict[str, Any]] = Field(None)
+
+    @classmethod
+    def from_inkeep_rag_response(cls, rag_item: Dict[str, Any]) -> "Document":
+        """Create a Document object from a single InKeep RAG response item.
+
+        Args:
+            rag_item: Single item from InKeep RAG response
+
+        Returns:
+            Document object with extracted content and metadata
+        """
+        source = rag_item.get("source", {})
+        text_content = cls._extract_text_from_source(source)
+
+        return cls(
+            content=text_content.strip() if text_content else "",
+            url=rag_item.get("url"),
+            title=rag_item.get("title"),
+            metadata={
+                "type": rag_item.get("type"),
+                "record_type": rag_item.get("record_type"),
+                "context": rag_item.get("context"),
+                "media_type": source.get("media_type"),
+            },
+        )
+
+    @staticmethod
+    def _extract_text_from_source(source: Dict[str, Any]) -> str:
+        """Extract text content from InKeep source object.
+
+        Args:
+            source: Source object from InKeep RAG response
+
+        Returns:
+            Extracted text content
+        """
+        # Try to extract from content array first
+        if "content" in source:
+            text_parts = []
+            for content_item in source["content"]:
+                if content_item.get("type") == "text" and content_item.get("text"):
+                    text_parts.append(content_item["text"])
+            if text_parts:
+                return "\n".join(text_parts)
+
+        # Fallback to source data
+        return source.get("data", "")

{rasa_pro-3.13.1a15 → rasa_pro-3.13.1a16}/rasa/builder/project_generator.py

@@ -12,6 +12,7 @@ import structlog
 from rasa.builder import config
 from rasa.builder.exceptions import ProjectGenerationError, ValidationError
 from rasa.builder.llm_service import get_skill_generation_messages, llm_service
+from rasa.builder.models import BotFiles
 from rasa.builder.validation_service import validate_project
 from rasa.cli.scaffold import ProjectTemplateName, create_initial_project
 from rasa.shared.core.flows import yaml_flows_io
@@ -178,9 +179,9 @@ class ProjectGenerator:
         except Exception as e:
             raise ValidationError(f"Failed to create importer: {e}")
 
-    def get_bot_files(self) -> Dict[str, Optional[str]]:
+    def get_bot_files(self) -> BotFiles:
         """Get the current bot files by reading from disk."""
-        bot_files: Dict[str, Optional[str]] = {}
+        bot_files: BotFiles = {}
 
         for file in self.project_folder.glob("**/*"):
             # Skip directories

{rasa_pro-3.13.1a15 → rasa_pro-3.13.1a16}/rasa/builder/service.py

@@ -18,9 +18,9 @@ from rasa.builder.llm_service import llm_service
 from rasa.builder.logging_utils import get_recent_logs
 from rasa.builder.models import (
     ApiErrorResponse,
-    ApiResponse,
     LLMBuilderContext,
     LLMBuilderRequest,
+    LLMHelperResponse,
     PromptRequest,
     ServerSentEvent,
     TemplateRequest,
@@ -449,7 +449,7 @@ async def handle_template_to_bot(request: Request) -> None:
 @openapi.tag("bot-files")
 @openapi.response(
     200,
-    {"application/json": model_to_schema(ApiResponse)},
+    {"application/json": {str: Optional[str]}},
     description="Bot files retrieved successfully",
 )
 @openapi.response(
@@ -461,25 +461,35 @@ async def get_bot_files(request: Request) -> HTTPResponse:
     """Get current bot files."""
     project_generator = get_project_generator(request)
     bot_files = project_generator.get_bot_files()
-    return response.json(
-        ApiResponse(
-            status="success",
-            message="Bot files fetched successfully",
-            data={"files": bot_files},
-        ).model_dump()
-    )
+    return response.json(bot_files)
 
 
 @bp.route("/files", methods=["PUT"])
 @openapi.summary("Update bot files")
 @openapi.description(
     "Updates the bot configuration files and retrains the model. "
-    "Returns server-sent events for real-time progress tracking."
+    "Returns server-sent events (SSE) for real-time progress tracking "
+    "through the entire update process.\n\n"
+    "**SSE Event Flow:**\n"
+    "1. `received` - Request received by server\n"
+    "2. `validating` - Validating bot configuration files\n"
+    "3. `validation_success` - File validation completed successfully\n"
+    "4. `training` - Training the bot model with updated files\n"
+    "5. `train_success` - Model training completed\n"
+    "6. `done` - Bot files update completed\n\n"
+    "**Error Events (can occur at any time):**\n"
+    "- `validation_error` - Bot configuration files are invalid\n"
+    "- `train_error` - Files updated but training failed\n"
+    "- `error` - Unexpected error occurred\n\n"
+    "**Usage:** Send PUT request with Content-Type: application/json and "
+    "Accept: text/event-stream"
 )
 @openapi.tag("bot-files")
 @openapi.body(
-    {"application/json": dict},
-    description="Bot files containing updated configuration files",
+    {"application/json": {"file_name": str}},
+    description="A dictionary mapping file names to their updated content. "
+    "The file name should be the name of the file in the project folder. "
+    "Files that are not in the request will not be updated.",
     required=True,
 )
 @openapi.response(
@@ -603,7 +613,7 @@ async def update_bot_files(request: Request) -> None:
 @openapi.tag("bot-data")
 @openapi.response(
     200,
-    {"application/json": model_to_schema(ApiResponse)},
+    {"application/json": model_to_schema(CALMUserData)},
     description="Bot data retrieved successfully",
 )
 @openapi.response(
@@ -617,13 +627,7 @@ async def get_bot_data(request: Request) -> HTTPResponse:
         project_generator = get_project_generator(request)
         calm_parts = extract_calm_import_parts_from_project_generator(project_generator)
 
-        return response.json(
-            ApiResponse(
-                status="success",
-                message="Bot data fetched successfully",
-                data=calm_parts.model_dump(),
-            ).model_dump()
-        )
+        return response.json(calm_parts.model_dump())
     except Exception as e:
         structlogger.error("bot_builder_service.get_bot_data.error", error=str(e))
         return response.json(
@@ -649,7 +653,7 @@ async def get_bot_data(request: Request) -> HTTPResponse:
 )
 @openapi.response(
     200,
-    {"application/json": dict},
+    {"application/json": model_to_schema(LLMHelperResponse)},
     description="LLM response with assistance and suggestions",
 )
 @openapi.response(

{rasa_pro-3.13.1a15 → rasa_pro-3.13.1a16}/rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.13.1a15"
+__version__ = "3.13.1a16"