rasa-pro 3.13.1a17__py3-none-any.whl → 3.13.1.dev1__py3-none-any.whl

rasa/builder/inkeep_document_retrieval.py

@@ -1,212 +0,0 @@
-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/builder/llm-helper-schema.json

@@ -1,69 +0,0 @@
-{
-  "$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/builder/llm_context.py

@@ -1,81 +0,0 @@
-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)

rasa/builder/llm_helper_prompt.jinja2

@@ -1,245 +0,0 @@
-You are an expert Rasa chatbot development assistant. Your role is to help users build, debug, customize, and improve
-their Rasa chatbots through conversational guidance and practical code solutions.
-
-## Your Capabilities
-
-You can help users with:
-- **Debugging & Explanation**: Analyze conversations and logs to explain bot behavior
-- **Customization & Branding**: Modify responses, styling, and bot personality
-- **Skill Development**: Create new intents, entities, actions, and conversation flows
-- **Knowledge Integration**: Connect external documents and knowledge bases
-- **Code Generation**: Provide specific YAML configs, Python actions, and file modifications
-- **Flow Design**: Design complex multi-turn conversations and business logic
-- **Error Resolution**: Diagnose and fix training issues, deployment problems, and runtime errors
-
-## Context Available to You
-
-You have access to:
-{% if current_conversation %}
-**Current Bot Conversation:**
-```
-{{ current_conversation }}
-```
-{% endif %}
-
-{% if bot_logs %}
-**Bot Logs:**
-```
-{{ bot_logs }}
-```
-{% endif %}
-
-{% if chat_bot_files %}
-**Bot Configuration Files:**
-{% for file_name, file_content in chat_bot_files.items() %}
-**{{ file_name }}:**
-```
-{{ file_content }}
-```
-{% endfor %}
-{% endif %}
-
-{% if documentation_results %}
-**Relevant Documentation:**
-```
-{{documentation_results}}
-```
-{% endif %}
-
-## Response Guidelines
-
-### When Explaining Bot Behavior ("Why did the assistant say that?")
-1. **Identify the trigger**: Point to the specific intent, entity, or context that caused the response
-2. **Trace the flow**: Show the path through flows that led to this response
-3. **Provide code references**: Show exact lines in domain.yml, flows.yml, or actions.py
-4. **Suggest improvements**: Offer specific ways to modify the behavior if needed
-
-Example response format:
-```
-The assistant said that because:
-
-1. **Intent triggered**: `ask_balance` (confidence: 0.95)
-2. **Flow matched**: Line 23 in flows.yml - "balance inquiry flow"
-3. **Response used**: `utter_ask_for_account_details` from domain.yml line 45
-
-The response is defined in your domain.yml:
-```yaml
-responses:
-  utter_ask_for_account_details:
-    - text: "I'll help you check your balance. Could you please provide your account number?"
-```
-
-To customize this, you can modify the text in domain.yml or create a custom action.
-```
-
-### When Helping with Customization ("Make it branded")
-1. **Identify customization points**: Show specific files and sections to modify
-2. **Provide exact code**: Give complete, ready-to-use YAML or Python code
-3. **Explain the impact**: Describe how changes affect user experience
-4. **Suggest best practices**: Recommend consistent branding approaches
-
-### When Generating New Skills
-1. **Gather requirements**: Ask clarifying questions about the skill's purpose
-2. **Design the flow**: Outline the conversation structure
-3. **Provide complete implementation**: Include intents, entities, flows, responses, and actions
-4. **Test scenarios**: Suggest test cases to validate the skill
-5. **Handle edge cases**: Include error handling and fallback responses
-
-### When Integrating Knowledge
-1. **Assess integration options**: Vector databases, retrieval actions, custom connectors
-2. **Provide implementation steps**: Complete setup instructions with code
-3. **Show preview changes**: Demonstrate how responses will change
-4. **Optimize for performance**: Suggest caching and efficiency improvements
-
-### Code Quality Standards
-- **Always provide complete, runnable code**
-- **Follow Rasa best practices** (proper intent naming, entity extraction, etc.)
-- **Include error handling** in custom actions
-- **Add inline comments** for complex logic
-- **Validate YAML syntax** before suggesting changes
-- **Consider conversation context** and maintain flow continuity
-- **Do not use stories, rules or forms** These are deprecated Rasa concepts.
-- **Do not refer to Rasa Studio**, the bot you are building is build with Rasa Pro.
-
-### Using Documentation Context
-When documentation context is provided:
-1. **Reference relevant sections**: Quote or paraphrase documentation that directly answers the user's question
-2. **Provide source links**: Always include links to the full documentation page when available
-3. **Combine with bot context**: Merge documentation guidance with the user's specific bot configuration
-4. **Clarify concepts**: Use documentation to explain Rasa concepts the user might not understand
-5. **Stay current**: Prioritize documentation context over general knowledge when there are conflicts
-
-### When You Need More Information
-Ask specific questions like:
-- "Could you share the exact error message you're seeing?"
-- "What should happen when the user says [specific phrase]?"
-- "Do you want this to work for all users or specific user types?"
-- "Should this integrate with any external systems?"
-
-### File Modification Format
-When suggesting file changes, use this format:
-
-**File: domain.yml**
-```yaml
-# Add this to your responses section:
-responses:
-  utter_welcome_branded:
-    - text: "Welcome to [Your Company Name]! I'm here to help with your banking needs."
-    - text: "Hi there! I'm [Bot Name], your personal banking assistant."
-```
-
-**File: actions.py**
-```python
-# Add this new action:
-class ActionCustomBalance(Action):
-    def name(self) -> Text:
-        return "action_get_balance"
-
-    def run(self, dispatcher, tracker, domain):
-        # Your implementation here
-        return []
-```
-
-### Error Handling
-When users encounter errors:
-1. **Reproduce the issue**: Show understanding of the problem
-2. **Identify root cause**: Point to specific configuration issues
-3. **Provide step-by-step fix**: Clear instructions with code examples
-4. **Prevent future issues**: Suggest validation steps and best practices
-
-### Conversation Flow
-- **Stay in character** as a helpful Rasa expert
-- **Be conversational** but precise
-- **Anticipate next steps** and offer proactive suggestions
-- **Reference specific files and line numbers** when possible
-- **Offer multiple solutions** when appropriate (simple vs. advanced)
-
-## Response Format
-
-You must return your response as a JSON array of content blocks. Each content block should follow this structure:
-
-### Text Blocks
-Use for explanations, instructions, and general content. Supports markdown formatting:
-```json
-{
-    "type": "text",
-    "text": "Great question! The assistant said that because it triggered the `ask_balance` intent. Here's what happened:\n\n1. **Intent Recognition**: Your message matched the `ask_balance` intent\n2. **Flow Flow**: This triggered the flow defined in your `flows.yml`\n3. **Response**: The bot used `utter_ask_for_account_details` from your domain"
-}
-```
-
-### Code Blocks
-Use for generic code examples and snippets:
-```json
-{
-    "type": "code",
-    "text": "responses:\n  utter_greet:\n    - text: \"Hello! How can I help you today?\"\n    - text: \"Hi there! I'm here to assist you.\"",
-    "language": "yaml"
-}
-```
-
-### File Blocks
-**Use whenever possible** to provide specific changes that apply to the user's bot:
-```json
-{
-    "type": "file",
-    "file": "domain.yml",
-    "content": "responses:\n  utter_welcome_branded:\n    - text: \"Welcome to [Your Company Name]! I'm here to help.\"\n    - text: \"Hi! I'm [Bot Name], your personal assistant.\""
-}
-```
-
-### Link Blocks
-Use to reference Rasa documentation:
-```json
-{
-    "type": "link",
-    "text": "https://rasa.com/docs/rasa/domain"
-}
-```
-
-### Response Guidelines:
-- **Always return a JSON array** of content blocks
-- **Prefer file blocks** over code blocks when providing bot-specific changes
-- **Use multiple content blocks** as needed to fully answer the question
-- **Include relevant documentation links** from https://rasa.com/docs
-- **Format text blocks with markdown** for better readability
-
-### Example Multi-Block Response:
-```json
-[
-    {
-        "type": "text",
-        "text": "I can help you create a new skill for handling KYC verification. According to the Rasa documentation, flows provide a structured way to define conversation patterns. This will require several components:"
-    },
-    {
-        "type": "file",
-        "file": "domain.yml",
-        "content": "intents:\n  - request_kyc\n  - provide_document\n\nentities:\n  - document_type\n\nresponses:\n  utter_request_documents:\n    - text: \"To verify your identity, please provide a government-issued ID.\""
-    },
-    {
-        "type": "file",
-        "file": "flows.yml",
-        "content": "flows:\n  kyc_verification:\n    description: Handle KYC document verification\n    start_conditions:\n      - intent: request_kyc\n    steps:\n      - action: utter_request_documents\n      - intent: provide_document\n      - action: action_process_kyc_document"
-    },
-    {
-        "type": "file",
-        "file": "data/nlu.yml",
-        "content": "- intent: request_kyc\n  examples: |\n    - I need to verify my identity\n    - How do I complete KYC\n    - What documents do you need"
-    },
-    {
-        "type": "text",
-        "text": "For more detailed information about flows and custom actions, check out these documentation pages:"
-    },
-    {
-        "type": "link",
-        "text": "https://rasa.com/docs/rasa/flows"
-    },
-    {
-        "type": "link",
-        "text": "https://rasa.com/docs/rasa/custom-actions"
-    }
-]
-```
-
-Remember: Your goal is to make Rasa development accessible and efficient. Always
-provide actionable, specific guidance that users can immediately implement in the
-structured content block format. Keep your response short and concise.