First Version

README.md

@@ -1,14 +1,109 @@
+README.md 
+# agent-demo-track
+# 🧭 Tat Twam AI — A Multi-Agent AI Coach for Personal and Spiritual Growth
+
+**Tat Twam AI** is an intelligent multi-agent application that serves as a personal, non-judgmental AI coach. Designed for individuals navigating life's personal and professional dilemmas, Tat Twam AI combines cutting-edge AI frameworks with timeless wisdom from classic spiritual and modern self-help texts.
+
+The product is designed to provide calming, insightful, and personalized guidance through a soothing, human-like conversation—helping users reflect, grow, and find direction.
+
+---
+
+## 🌟 Key Features
+
+- 🎙️ Accepts **voice input** in user's mother tongue or **text input** in English
+- 💬 Engages users with **soothing, reflective dialogue**
+- 📚 Draws wisdom from **13 timeless spiritual and self-help texts**
+- 🤖 Built on a **multi-agent architecture** using state-of-the-art LLM tools
+- 🔁 Offers **context-aware**, **personalized suggestions** with guardrails
+- 🧘‍♀️ Responds in a **calm, meditative voice**, promoting inner peace
+
 ---
-title: TatTwamAI
-emoji: 🏃
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.33.1
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: A Multi-Agent AI Coach for Personal and Spiritual Growth
+
+## 🧩 System Architecture
+
+The core logic of Tat Twam AI is implemented using **four intelligent agents**, each responsible for a specific part of the coaching journey:
+
+### 🧠 Agent 1: The Listener & Summarizer
+- **Input:** Voice (in user's mother tongue) or text (in English)
+- **Functionality:**
+  - Converts speech to English text
+  - Conducts a gentle Q&A session to uncover the user’s core problem
+  - Summarizes the conversation
+  - Analyzes tone and emotional sentiment
+- **Tools:**
+  - ASR (Speech-to-text) with multilingual support
+  - Sentiment analysis
+  - Conversational Q&A
+  - Summary generator
+
+### 📘 Agent 2: The Wisdom Engine
+- **Input:** Summary, tone, and sentiment from Agent 1
+- **Functionality:**
+  - Retrieves spiritual or self-help insights using a **RAG (Retrieval-Augmented Generation)** system
+  - Offers customized reflections, techniques, or meditations relevant to the user’s current issue
+- **Knowledge Base Includes:**
+  1. *Autobiography of a Yogi*
+  2. *Gita Vahini*
+  3. *The Power of Now*
+  4. *Man's Search for Meaning*
+  5. *Bhagavad Gita As It Is*
+  6. *Meditations* (Marcus Aurelius)
+  7. *The Tao Te Ching*
+  8. *Dhyana Vahini*
+  9. *Atomic Habits*
+  10. *The 7 Habits of Highly Effective People*
+  11. *Mindset* (Carol Dweck)
+  12. *Prema Vahini*
+  13. *Prasnothara Vahini*
+- **Tools:** Custom RAG pipeline + embedding-based retrieval + fine-tuned LLMs
+
+### 🛡 Agent 3: The Inner Critic & Guardian
+- **Input:** Suggested output from Agent 2
+- **Functionality:**
+  - Implements **guardrails** to ensure spiritual, ethical, and emotional appropriateness
+  - Adjusts tone and verifies factuality, empathy, and personalization
+  - Converts final output to voice with a **mild, meditative female tone**
+- **Tools:** LLM-as-Judge, Voice synthesis
+
+### 🔄 Agent 4: The Satisfaction Checker
+- **Functionality:**
+  - Asks for user satisfaction and feedback
+  - Decides whether to continue or close the session
+  - Passes feedback to Agent 1 for context-aware follow-up
+- **Tools:** User feedback processing, memory/context management
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 💬 Sample Flow
+
+1. **User speaks:** “I feel lost about my career direction.” (in Hindi)
+2. **Agent 1:** Asks reflective questions like: *“What matters most to you right now?”*
+3. **Agent 2:** Responds with insights from *The Power of Now* and *Gita Vahini*
+4. **Agent 3:** Ensures calm, helpful delivery in a soothing voice
+5. **Agent 4:** Asks: “Did that help you gain clarity?” → If yes, ends. If no, loop continues.
+
+---
+
+## 🎯 Vision
+
+Tat Twam AI aspires to be your **non-judgmental companion for inner clarity**, integrating deep ancient wisdom with today's AI technology. Its goal is not to give you answers, but to gently **guide you inward to find your own**.
+
+---
+
+## 🚧 Coming Soon
+
+- 📱 Mobile app with voice interface
+- 🧾 Journaling feature synced with conversation history
+- 🔄 Multi-language support for responses
+- 🔒 End-to-end encryption and privacy-first design
+
+---
+
+## 📬 Contact
+
+Interested in collaborating, contributing, or piloting this application? Reach out at **[saishree999@gmail.com]**
+
+---
+
+> *"The answers you seek will come when your mind is quiet enough to hear them."* —Tat Twam AI
+

agents/_init_.py

@@ -0,0 +1,118 @@
+"""
+Agents module for Personal Coach CrewAI Application
+Contains all agent definitions and orchestration logic
+"""
+
+from typing import TYPE_CHECKING
+
+# Version info
+__version__ = "1.0.0"
+__author__ = "Personal Coach AI Team"
+
+# Lazy imports to avoid circular dependencies
+if TYPE_CHECKING:
+    from .crew_agents import (
+        ConversationHandlerAgent,
+        WisdomAdvisorAgent,
+        ResponseValidatorAgent,
+        InteractionManagerAgent,
+        PersonalCoachCrew
+    )
+
+# Define what should be imported with "from agents import *"
+__all__ = [
+    # Main agents
+    "ConversationHandlerAgent",
+    "WisdomAdvisorAgent", 
+    "ResponseValidatorAgent",
+    "InteractionManagerAgent",
+    
+    # Crew orchestrator
+    "PersonalCoachCrew",
+    
+    # Agent utilities
+    "create_all_agents",
+    "get_agent_by_role",
+    
+    # Constants
+    "AGENT_ROLES",
+    "AGENT_GOALS"
+]
+
+# Agent role constants
+AGENT_ROLES = {
+    "CONVERSATION_HANDLER": "Empathetic Conversation Handler",
+    "WISDOM_ADVISOR": "Knowledge and Wisdom Advisor",
+    "RESPONSE_VALIDATOR": "Response Quality Validator", 
+    "INTERACTION_MANAGER": "Interaction Flow Manager"
+}
+
+# Agent goals
+AGENT_GOALS = {
+    "CONVERSATION_HANDLER": "Understand user's emotional state and needs through empathetic dialogue",
+    "WISDOM_ADVISOR": "Provide relevant wisdom and practical guidance from knowledge base",
+    "RESPONSE_VALIDATOR": "Ensure responses are safe, appropriate, and supportive",
+    "INTERACTION_MANAGER": "Manage conversation flow and deliver responses effectively"
+}
+
+# Lazy loading functions
+def create_all_agents(config):
+    """
+    Factory function to create all agents with proper configuration
+    
+    Args:
+        config: Configuration object with necessary settings
+        
+    Returns:
+        dict: Dictionary of initialized agents
+    """
+    from .crew_agents import (
+        ConversationHandlerAgent,
+        WisdomAdvisorAgent,
+        ResponseValidatorAgent,
+        InteractionManagerAgent
+    )
+    
+    agents = {
+        "conversation_handler": ConversationHandlerAgent(config),
+        "wisdom_advisor": WisdomAdvisorAgent(config),
+        "response_validator": ResponseValidatorAgent(config),
+        "interaction_manager": InteractionManagerAgent(config)
+    }
+    
+    return agents
+
+def get_agent_by_role(role: str, config):
+    """
+    Get a specific agent by its role
+    
+    Args:
+        role: Agent role constant
+        config: Configuration object
+        
+    Returns:
+        Agent instance or None
+    """
+    from .crew_agents import (
+        ConversationHandlerAgent,
+        WisdomAdvisorAgent,
+        ResponseValidatorAgent,
+        InteractionManagerAgent
+    )
+    
+    agent_map = {
+        "CONVERSATION_HANDLER": ConversationHandlerAgent,
+        "WISDOM_ADVISOR": WisdomAdvisorAgent,
+        "RESPONSE_VALIDATOR": ResponseValidatorAgent,
+        "INTERACTION_MANAGER": InteractionManagerAgent
+    }
+    
+    agent_class = agent_map.get(role)
+    if agent_class:
+        return agent_class(config)
+    return None
+
+# Module initialization message (only in debug mode)
+import os
+if os.getenv("DEBUG_MODE", "false").lower() == "true":
+    print(f"Agents module v{__version__} initialized")

agents/crew_agents.py

@@ -0,0 +1,83 @@
+"""
+CrewAI Agent Definitions using modular tool containers
+"""
+
+from crewai import Agent
+from agents.tools import VoiceTools, LLMTools, KnowledgeTools, ValidationTools
+
+# Instantiate tool containers ONCE (avoid repeated model loads, shared across agents)
+voice_tools = VoiceTools()
+llm_tools = LLMTools()
+knowledge_tools = KnowledgeTools()
+validation_tools = ValidationTools()
+
+def create_conversation_agent(llm) -> Agent:
+    """Agent 1: Conversation Handler with emotional intelligence"""
+    return Agent(
+        role="Empathetic Conversation Handler",
+        goal="Understand user's emotional state and needs through compassionate dialogue",
+        backstory="""You are a highly empathetic listener trained in counseling psychology
+        and multicultural communication. You understand nuances in different languages and
+        cultural contexts. Your strength lies in making people feel heard and understood.""",
+        tools=[
+            voice_tools.detect_emotion,
+            voice_tools.generate_reflective_questions
+        ],
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+
+def create_wisdom_agent(llm) -> Agent:
+    """Agent 2: Wisdom Keeper with knowledge from spiritual texts"""
+    return Agent(
+        role="Wisdom Keeper and Spiritual Guide",
+        goal="Provide personalized guidance drawing from ancient wisdom and modern psychology",
+        backstory="""You are a learned guide who has deeply studied various spiritual texts,
+        philosophical works, and modern psychology. You excel at finding relevant wisdom
+        that speaks to each person's unique situation and presenting it in an accessible way.""",
+        tools=[
+            knowledge_tools.search_knowledge,
+            knowledge_tools.extract_wisdom,
+            knowledge_tools.suggest_practices,
+            llm_tools.mistral_chat,
+            llm_tools.generate_advice
+        ],
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+
+def create_validation_agent(llm) -> Agent:
+    """Agent 3: Guardian ensuring safe and appropriate responses"""
+    return Agent(
+        role="Response Guardian and Quality Validator",
+        goal="Ensure all responses are safe, appropriate, and truly helpful",
+        backstory="""You are a careful guardian who ensures all guidance is ethical,
+        safe, and beneficial. You have expertise in mental health awareness and
+        understand the importance of appropriate boundaries in coaching.""",
+        tools=[
+            validation_tools.check_safety if hasattr(validation_tools, 'check_safety') else validation_tools.validate_response,
+            validation_tools.validate_tone if hasattr(validation_tools, 'validate_tone') else None,
+            validation_tools.refine_response if hasattr(validation_tools, 'refine_response') else None
+        ],
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+
+def create_interaction_agent(llm) -> Agent:
+    """Agent 4: Interaction Manager for natural dialogue"""
+    return Agent(
+        role="Conversation Flow Manager",
+        goal="Create natural, engaging dialogue that helps users on their journey",
+        backstory="""You are a skilled facilitator who ensures conversations flow
+        naturally and meaningfully. You understand the importance of pacing, follow-up
+        questions, and creating a safe space for exploration.""",
+        tools=[
+            llm_tools.summarize_conversation
+        ],
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )

agents/crew_agents_old.py

@@ -0,0 +1,96 @@
+"""
+CrewAI Agent Definitions with direct model integration
+"""
+
+from crewai import Agent
+from agents.tools.voice_tools import (
+    TranscribeTool,
+    DetectEmotionTool,
+    GenerateQuestionsTool
+)
+from agents.tools.llm_tools import (
+    MistralChatTool,
+    GenerateAdviceTool,
+    SummarizeTool
+)
+from agents.tools.knowledge_tools import (
+    SearchKnowledgeTool,
+    ExtractWisdomTool,
+    SuggestPracticeTool
+)
+from agents.tools.validation_tools import (
+    CheckSafetyTool,
+    ValidateToneTool,
+    RefineTool
+)
+
+def create_conversation_agent(llm) -> Agent:
+    """Agent 1: Conversation Handler with emotional intelligence"""
+    return Agent(
+        role="Empathetic Conversation Handler",
+        goal="Understand user's emotional state and needs through compassionate dialogue",
+        backstory="""You are a highly empathetic listener trained in counseling psychology 
+        and multicultural communication. You understand nuances in different languages and 
+        cultural contexts. Your strength lies in making people feel heard and understood.""",
+        tools=[
+            DetectEmotionTool(),
+            GenerateQuestionsTool()
+        ],
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+
+def create_wisdom_agent(llm) -> Agent:
+    """Agent 2: Wisdom Keeper with knowledge from spiritual texts"""
+    return Agent(
+        role="Wisdom Keeper and Spiritual Guide",
+        goal="Provide personalized guidance drawing from ancient wisdom and modern psychology",
+        backstory="""You are a learned guide who has deeply studied various spiritual texts,
+        philosophical works, and modern psychology. You excel at finding relevant wisdom
+        that speaks to each person's unique situation and presenting it in an accessible way.""",
+        tools=[
+            SearchKnowledgeTool(),
+            ExtractWisdomTool(),
+            SuggestPracticeTool(),
+            MistralChatTool(),
+            GenerateAdviceTool()
+        ],
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+
+def create_validation_agent(llm) -> Agent:
+    """Agent 3: Guardian ensuring safe and appropriate responses"""
+    return Agent(
+        role="Response Guardian and Quality Validator",
+        goal="Ensure all responses are safe, appropriate, and truly helpful",
+        backstory="""You are a careful guardian who ensures all guidance is ethical,
+        safe, and beneficial. You have expertise in mental health awareness and 
+        understand the importance of appropriate boundaries in coaching.""",
+        tools=[
+            CheckSafetyTool(),
+            ValidateToneTool(),
+            RefineTool()
+        ],
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )
+
+def create_interaction_agent(llm) -> Agent:
+    """Agent 4: Interaction Manager for natural dialogue"""
+    return Agent(
+        role="Conversation Flow Manager",
+        goal="Create natural, engaging dialogue that helps users on their journey",
+        backstory="""You are a skilled facilitator who ensures conversations flow
+        naturally and meaningfully. You understand the importance of pacing, follow-up
+        questions, and creating a safe space for exploration.""",
+        tools=[
+            SummarizeTool()
+        ],
+        llm=llm,
+        verbose=True,
+        allow_delegation=False
+    )

agents/tools/_init_.py

@@ -0,0 +1,131 @@
+"""
+Agent Tools module for Personal Coach CrewAI Application
+Contains specialized tools for each agent's functionality.
+Supports modular class-based tool containers.
+"""
+from typing import TYPE_CHECKING, Dict, Any
+
+# Version info
+__version__ = "1.0.0"
+
+# Lazy imports for type checking and IDE intellisense
+if TYPE_CHECKING:
+    from .voice_tools import VoiceTools
+    from .llm_tools import LLMTools
+    from .knowledge_tools import KnowledgeTools
+    from .validation_tools import ValidationTools
+
+# Public API: expose only main class-based containers & API
+__all__ = [
+    # Tool containers
+    "VoiceTools",
+    "LLMTools",
+    "KnowledgeTools",
+    "ValidationTools",
+    # Factory and utility functions
+    "create_tool_suite",
+    "get_tool_by_name",
+    "register_tools_with_crew",
+    # Constants
+    "SUPPORTED_LANGUAGES",
+    "TOOL_CATEGORIES"
+]
+
+# Constants
+SUPPORTED_LANGUAGES = [
+    "en", "es", "fr", "de", "it", "pt", "ru", "zh",
+    "ja", "ko", "hi", "ar", "bn", "pa", "te", "mr",
+    "ta", "ur", "gu", "kn", "ml", "or"
+]
+
+TOOL_CATEGORIES = {
+    "VOICE": ["speech_to_text", "text_to_speech", "language_detection"],
+    "LLM": ["generate_response", "generate_questions", "summarize", "paraphrase"],
+    "KNOWLEDGE": ["search_knowledge", "extract_wisdom", "find_practices"],
+    "VALIDATION": ["validate_response", "check_safety", "analyze_tone"]
+}
+
+# Factory: unified tool suite
+def create_tool_suite(config) -> Dict[str, Any]:
+    """
+    Create a complete suite of tools for all agents.
+
+    Args:
+        config: Configuration object
+
+    Returns:
+        dict: Dictionary of initialized tool containers
+    """
+    from .voice_tools import VoiceTools
+    from .llm_tools import LLMTools
+    from .knowledge_tools import KnowledgeTools
+    from .validation_tools import ValidationTools
+    return {
+        "voice": VoiceTools(config),
+        "llm": LLMTools(config),
+        "knowledge": KnowledgeTools(config),
+        "validation": ValidationTools(config)
+    }
+
+def get_tool_by_name(tool_name: str, config):
+    """
+    Get a specific tool container by name.
+
+    Args:
+        tool_name: Name of the tool container ('voice', 'llm', 'knowledge', 'validation')
+        config: Configuration object
+
+    Returns:
+        Tool container class instance or None
+    """
+    tool_mapping = {
+        "voice": lambda c: __import__("agents.tools.voice_tools", fromlist=["VoiceTools"]).VoiceTools(c),
+        "llm": lambda c: __import__("agents.tools.llm_tools", fromlist=["LLMTools"]).LLMTools(c),
+        "knowledge": lambda c: __import__("agents.tools.knowledge_tools", fromlist=["KnowledgeTools"]).KnowledgeTools(c),
+        "validation": lambda c: __import__("agents.tools.validation_tools", fromlist=["ValidationTools"]).ValidationTools(c),
+    }
+    tool_factory = tool_mapping.get(tool_name.lower())
+    if tool_factory:
+        return tool_factory(config)
+    return None
+
+# Tool registry for CrewAI (for UI/metadata/documentation)
+def register_tools_with_crew():
+    """
+    Register all tools with CrewAI framework.
+    Returns a list of tool configurations for CrewAI.
+    """
+    return [
+        {
+            "name": "speech_to_text",
+            "description": "Convert speech in any language to text",
+            "category": "VOICE"
+        },
+        {
+            "name": "text_to_speech",
+            "description": "Convert text to natural speech in multiple languages",
+            "category": "VOICE"
+        },
+        {
+            "name": "search_knowledge",
+            "description": "Search through spiritual and self-help texts",
+            "category": "KNOWLEDGE"
+        },
+        {
+            "name": "generate_response",
+            "description": "Generate empathetic and helpful responses",
+            "category": "LLM"
+        },
+        {
+            "name": "validate_response",
+            "description": "Ensure response safety and appropriateness",
+            "category": "VALIDATION"
+        }
+    ]
+
+# Initialization check for debug mode
+import os
+if os.getenv("DEBUG_MODE", "false").lower() == "true":
+    print(f"Agent Tools module v{__version__} initialized")
+    print(f"Supported languages: {len(SUPPORTED_LANGUAGES)}")
+    print(f"Tool categories: {list(TOOL_CATEGORIES.keys())}")

agents/tools/_init_old.py

@@ -0,0 +1,151 @@
+"""
+Agent Tools module for Personal Coach CrewAI Application
+Contains specialized tools for each agent's functionality
+"""
+
+from typing import TYPE_CHECKING, Dict, Any
+
+# Version info
+__version__ = "1.0.0"
+
+# Lazy imports
+if TYPE_CHECKING:
+    from .voice_tools import VoiceTools, MultilingualSTT, MultilingualTTS
+    from .llm_tools import LLMTools, MistralModel, PromptGenerator
+    from .knowledge_tools import KnowledgeTools, RAGPipeline, ContextBuilder
+    from .validation_tools import ValidationTools, ValidationResult
+
+# Public API
+__all__ = [
+    # Voice tools
+    "VoiceTools",
+    "MultilingualSTT",
+    "MultilingualTTS",
+    
+    # LLM tools
+    "LLMTools", 
+    "MistralModel",
+    "PromptGenerator",
+    
+    # Knowledge tools
+    "KnowledgeTools",
+    "RAGPipeline",
+    "ContextBuilder",
+    
+    # Validation tools
+    "ValidationTools",
+    "ValidationResult",
+    
+    # Utility functions
+    "create_tool_suite",
+    "get_tool_by_name",
+    
+    # Constants
+    "SUPPORTED_LANGUAGES",
+    "TOOL_CATEGORIES"
+]
+
+# Constants
+SUPPORTED_LANGUAGES = [
+    "en", "es", "fr", "de", "it", "pt", "ru", "zh",
+    "ja", "ko", "hi", "ar", "bn", "pa", "te", "mr",
+    "ta", "ur", "gu", "kn", "ml", "or"
+]
+
+TOOL_CATEGORIES = {
+    "VOICE": ["speech_to_text", "text_to_speech", "language_detection"],
+    "LLM": ["generate_response", "generate_questions", "summarize", "paraphrase"],
+    "KNOWLEDGE": ["search_knowledge", "extract_wisdom", "find_practices"],
+    "VALIDATION": ["validate_response", "check_safety", "analyze_tone"]
+}
+
+# Factory functions
+def create_tool_suite(config) -> Dict[str, Any]:
+    """
+    Create a complete suite of tools for all agents
+    
+    Args:
+        config: Configuration object
+        
+    Returns:
+        dict: Dictionary of initialized tools
+    """
+    from .voice_tools import VoiceTools
+    from .llm_tools import LLMTools
+    from .knowledge_tools import KnowledgeTools
+    from .validation_tools import ValidationTools
+    
+    tools = {
+        "voice": VoiceTools(config),
+        "llm": LLMTools(config),
+        "knowledge": KnowledgeTools(config),
+        "validation": ValidationTools(config)
+    }
+    
+    return tools
+
+def get_tool_by_name(tool_name: str, config):
+    """
+    Get a specific tool by name
+    
+    Args:
+        tool_name: Name of the tool
+        config: Configuration object
+        
+    Returns:
+        Tool instance or None
+    """
+    tool_mapping = {
+        "voice": lambda c: __import__("agents.tools.voice_tools", fromlist=["VoiceTools"]).VoiceTools(c),
+        "llm": lambda c: __import__("agents.tools.llm_tools", fromlist=["LLMTools"]).LLMTools(c),
+        "knowledge": lambda c: __import__("agents.tools.knowledge_tools", fromlist=["KnowledgeTools"]).KnowledgeTools(c),
+        "validation": lambda c: __import__("agents.tools.validation_tools", fromlist=["ValidationTools"]).ValidationTools(c)
+    }
+    
+    tool_factory = tool_mapping.get(tool_name.lower())
+    if tool_factory:
+        return tool_factory(config)
+    return None
+
+# Tool registry for CrewAI
+def register_tools_with_crew():
+    """
+    Register all tools with CrewAI framework
+    Returns a list of tool configurations for CrewAI
+    """
+    tool_configs = [
+        {
+            "name": "speech_to_text",
+            "description": "Convert speech in any language to text",
+            "category": "VOICE"
+        },
+        {
+            "name": "text_to_speech", 
+            "description": "Convert text to natural speech in multiple languages",
+            "category": "VOICE"
+        },
+        {
+            "name": "search_knowledge",
+            "description": "Search through spiritual and self-help texts",
+            "category": "KNOWLEDGE"
+        },
+        {
+            "name": "generate_response",
+            "description": "Generate empathetic and helpful responses",
+            "category": "LLM"
+        },
+        {
+            "name": "validate_response",
+            "description": "Ensure response safety and appropriateness",
+            "category": "VALIDATION"
+        }
+    ]
+    
+    return tool_configs
+
+# Initialization check
+import os
+if os.getenv("DEBUG_MODE", "false").lower() == "true":
+    print(f"Agent Tools module v{__version__} initialized")
+    print(f"Supported languages: {len(SUPPORTED_LANGUAGES)}")
+    print(f"Tool categories: {list(TOOL_CATEGORIES.keys())}")

agents/tools/knowledge_tools.py

@@ -0,0 +1,105 @@
+"""
+Knowledge Base Tools for RAG (modular class version)
+"""
+from utils.knowledge_base import KnowledgeBase
+
+class KnowledgeTools:
+    def __init__(self, config=None):
+        self.config = config
+        self.kb = KnowledgeBase()
+
+    def search_knowledge(self, query: str, k: int = 5):
+        """Search spiritual and self-help texts for relevant wisdom."""
+        if not self.kb.is_initialized():
+            return [{
+                "text": "Wisdom comes from understanding ourselves.",
+                "source": "General Wisdom",
+                "score": 1.0
+            }]
+        return self.kb.search(query, k=k)
+
+    def extract_wisdom(self, search_results: list, user_context: dict):
+        """Extract most relevant wisdom for user's situation."""
+        emotion = user_context.get("primary_emotion", "neutral")
+        concerns = user_context.get("concerns", [])
+        scored_results = []
+        for result in search_results:
+            score = result["score"]
+            # Boost score if emotion matches
+            if emotion.lower() in result["text"].lower():
+                score *= 1.5
+            # Boost score if concerns match
+            for concern in concerns:
+                if concern.lower() in result["text"].lower():
+                    score *= 1.3
+            result["relevance_score"] = score
+            scored_results.append(result)
+        scored_results.sort(key=lambda x: x["relevance_score"], reverse=True)
+        return scored_results[:3]
+
+    def suggest_practices(self, emotional_state: str, cultural_context: str = None):
+        """Suggest appropriate meditation or practice."""
+        practices = {
+            "anxiety": {
+                "name": "Box Breathing Technique",
+                "description": "A powerful technique used by Navy SEALs to calm anxiety",
+                "steps": [
+                    "Sit comfortably with back straight",
+                    "Exhale all air from your lungs",
+                    "Inhale through nose for 4 counts",
+                    "Hold breath for 4 counts",
+                    "Exhale through mouth for 4 counts",
+                    "Hold empty for 4 counts",
+                    "Repeat 4-8 times"
+                ],
+                "benefits": "Activates parasympathetic nervous system, reduces cortisol",
+                "duration": "5-10 minutes",
+                "origin": "Modern breathwork"
+            },
+            "sadness": {
+                "name": "Metta (Loving-Kindness) Meditation",
+                "description": "Ancient Buddhist practice to cultivate compassion",
+                "steps": [
+                    "Sit comfortably, close your eyes",
+                    "Place hand on heart",
+                    "Begin with self: 'May I be happy, may I be peaceful'",
+                    "Extend to loved ones",
+                    "Include neutral people",
+                    "Embrace difficult people",
+                    "Radiate to all beings"
+                ],
+                "benefits": "Increases self-compassion, reduces depression",
+                "duration": "15-20 minutes",
+                "origin": "Buddhist tradition"
+            },
+            "stress": {
+                "name": "Progressive Muscle Relaxation",
+                "description": "Systematic tension and release technique",
+                "steps": [
+                    "Lie down comfortably",
+                    "Start with toes - tense for 5 seconds",
+                    "Release suddenly, notice relaxation",
+                    "Move up through each muscle group",
+                    "Face and scalp last",
+                    "Rest in full body relaxation"
+                ],
+                "benefits": "Reduces physical tension, improves sleep",
+                "duration": "15-20 minutes",
+                "origin": "Dr. Edmund Jacobson, 1920s"
+            }
+        }
+        default = {
+            "name": "Mindful Breathing",
+            "description": "Foundation of all meditation practices",
+            "steps": [
+                "Sit comfortably",
+                "Follow natural breath",
+                "Count breaths 1-10",
+                "Start again when distracted",
+                "No judgment, just awareness"
+            ],
+            "benefits": "Calms mind, improves focus",
+            "duration": "5-15 minutes",
+            "origin": "Universal practice"
+        }
+        return practices.get(emotional_state.lower(), default)

agents/tools/knowledge_tools_old.py

@@ -0,0 +1,131 @@
+"""
+Knowledge Base Tools for RAG
+"""
+
+from crewai.tools import BaseTool
+from utils.knowledge_base import KnowledgeBase
+from typing import List, Dict
+
+class SearchKnowledgeTool(BaseTool):
+    name: str = "search_spiritual_texts"
+    description: str = "Search spiritual and self-help texts for relevant wisdom"
+    
+    def __init__(self):
+        super().__init__()
+        self.kb = KnowledgeBase()
+    
+    def _run(self, query: str, k: int = 5) -> List[Dict]:
+        """Search knowledge base"""
+        if not self.kb.is_initialized():
+            return [{
+                "text": "Wisdom comes from understanding ourselves.",
+                "source": "General Wisdom",
+                "score": 1.0
+            }]
+        
+        results = self.kb.search(query, k=k)
+        return results
+
+class ExtractWisdomTool(BaseTool):
+    name: str = "extract_relevant_wisdom"
+    description: str = "Extract most relevant wisdom for user's situation"
+    
+    def _run(self, search_results: List[Dict], user_context: Dict) -> List[Dict]:
+        """Filter and rank wisdom based on relevance"""
+        emotion = user_context.get("primary_emotion", "neutral")
+        concerns = user_context.get("concerns", [])
+        
+        # Score each result based on relevance
+        scored_results = []
+        for result in search_results:
+            score = result["score"]
+            
+            # Boost score if emotion matches
+            if emotion.lower() in result["text"].lower():
+                score *= 1.5
+            
+            # Boost score if concerns match
+            for concern in concerns:
+                if concern.lower() in result["text"].lower():
+                    score *= 1.3
+            
+            result["relevance_score"] = score
+            scored_results.append(result)
+        
+        # Sort by relevance
+        scored_results.sort(key=lambda x: x["relevance_score"], reverse=True)
+        
+        return scored_results[:3]
+
+class SuggestPracticeTool(BaseTool):
+    name: str = "suggest_meditation_practice"
+    description: str = "Suggest appropriate meditation or practice"
+    
+    def _run(self, emotional_state: str, cultural_context: str = None) -> Dict:
+        """Suggest practice based on emotional state"""
+        practices = {
+            "anxiety": {
+                "name": "Box Breathing Technique",
+                "description": "A powerful technique used by Navy SEALs to calm anxiety",
+                "steps": [
+                    "Sit comfortably with back straight",
+                    "Exhale all air from your lungs",
+                    "Inhale through nose for 4 counts",
+                    "Hold breath for 4 counts",
+                    "Exhale through mouth for 4 counts",
+                    "Hold empty for 4 counts",
+                    "Repeat 4-8 times"
+                ],
+                "benefits": "Activates parasympathetic nervous system, reduces cortisol",
+                "duration": "5-10 minutes",
+                "origin": "Modern breathwork"
+            },
+            "sadness": {
+                "name": "Metta (Loving-Kindness) Meditation",
+                "description": "Ancient Buddhist practice to cultivate compassion",
+                "steps": [
+                    "Sit comfortably, close your eyes",
+                    "Place hand on heart",
+                    "Begin with self: 'May I be happy, may I be peaceful'",
+                    "Extend to loved ones",
+                    "Include neutral people",
+                    "Embrace difficult people",
+                    "Radiate to all beings"
+                ],
+                "benefits": "Increases self-compassion, reduces depression",
+                "duration": "15-20 minutes",
+                "origin": "Buddhist tradition"
+            },
+            "stress": {
+                "name": "Progressive Muscle Relaxation",
+                "description": "Systematic tension and release technique",
+                "steps": [
+                    "Lie down comfortably",
+                    "Start with toes - tense for 5 seconds",
+                    "Release suddenly, notice relaxation",
+                    "Move up through each muscle group",
+                    "Face and scalp last",
+                    "Rest in full body relaxation"
+                ],
+                "benefits": "Reduces physical tension, improves sleep",
+                "duration": "15-20 minutes",
+                "origin": "Dr. Edmund Jacobson, 1920s"
+            }
+        }
+        
+        default = {
+            "name": "Mindful Breathing",
+            "description": "Foundation of all meditation practices",
+            "steps": [
+                "Sit comfortably",
+                "Follow natural breath",
+                "Count breaths 1-10",
+                "Start again when distracted",
+                "No judgment, just awareness"
+            ],
+            "benefits": "Calms mind, improves focus",
+            "duration": "5-15 minutes",
+            "origin": "Universal practice"
+        }
+        
+        return practices.get(emotional_state.lower(), default)

agents/tools/llm_tools.py

@@ -0,0 +1,54 @@
+"""
+Mistral LLM Tools for CrewAI (modular class version)
+"""
+from models.mistral_model import MistralModel
+
+class LLMTools:
+    def __init__(self, config=None):
+        self.config = config
+        self.model = MistralModel()
+
+    def mistral_chat(self, prompt: str, context: dict = None) -> str:
+        """Chat with Mistral AI for intelligent responses."""
+        if context:
+            full_prompt = f"""
+            Context: {context}
+            User Query: {prompt}
+            Provide a thoughtful, compassionate response.
+            """
+        else:
+            full_prompt = prompt
+        return self.model.generate(full_prompt)
+
+    def generate_advice(self, user_analysis: dict, wisdom_quotes: list) -> str:
+        """Generate personalized advice based on user's situation."""
+        prompt = f"""
+        Based on this user analysis:
+        - Emotional state: {user_analysis.get('primary_emotion')}
+        - Concerns: {user_analysis.get('concerns')}
+        - Needs: {user_analysis.get('needs')}
+        And these relevant wisdom quotes:
+        {wisdom_quotes}
+        Generate compassionate, personalized advice that:
+        1. Acknowledges their feelings
+        2. Offers practical guidance
+        3. Includes relevant wisdom
+        4. Suggests actionable steps
+        5. Maintains hope and encouragement
+        Be specific to their situation, not generic.
+        """
+        return self.model.generate(prompt, max_length=500)
+
+    def summarize_conversation(self, conversation: list) -> str:
+        """Summarize conversation maintaining key insights."""
+        prompt = f"""
+        Summarize this coaching conversation:
+        {conversation}
+        Include:
+        1. Main concerns discussed
+        2. Key insights shared
+        3. Progress made
+        4. Next steps suggested
+        Keep it concise but meaningful.
+        """
+        return self.model.generate(prompt, max_length=200)

agents/tools/llm_tools_old.py

@@ -0,0 +1,86 @@
+"""
+Mistral LLM Tools for CrewAI
+"""
+
+from crewai.tools import BaseTool
+from models.mistral_model import MistralModel
+from typing import Dict, List
+
+class MistralChatTool(BaseTool):
+    name: str = "mistral_chat"
+    description: str = "Chat with Mistral AI for intelligent responses"
+    
+    def __init__(self):
+        super().__init__()
+        self.model = MistralModel()
+    
+    def _run(self, prompt: str, context: dict = None) -> str:
+        """Generate response using Mistral"""
+        if context:
+            full_prompt = f"""
+            Context: {context}
+            
+            User Query: {prompt}
+            
+            Provide a thoughtful, compassionate response.
+            """
+        else:
+            full_prompt = prompt
+        
+        return self.model.generate(full_prompt)
+
+class GenerateAdviceTool(BaseTool):
+    name: str = "generate_personalized_advice"
+    description: str = "Generate personalized advice based on user's situation"
+    
+    def __init__(self):
+        super().__init__()
+        self.model = MistralModel()
+    
+    def _run(self, user_analysis: dict, wisdom_quotes: list) -> str:
+        """Generate personalized advice"""
+        prompt = f"""
+        Based on this user analysis:
+        - Emotional state: {user_analysis.get('primary_emotion')}
+        - Concerns: {user_analysis.get('concerns')}
+        - Needs: {user_analysis.get('needs')}
+        
+        And these relevant wisdom quotes:
+        {wisdom_quotes}
+        
+        Generate compassionate, personalized advice that:
+        1. Acknowledges their feelings
+        2. Offers practical guidance
+        3. Includes relevant wisdom
+        4. Suggests actionable steps
+        5. Maintains hope and encouragement
+        
+        Be specific to their situation, not generic.
+        """
+        
+        return self.model.generate(prompt, max_length=500)
+
+class SummarizeTool(BaseTool):
+    name: str = "summarize_conversation"
+    description: str = "Summarize conversation maintaining key insights"
+    
+    def __init__(self):
+        super().__init__()
+        self.model = MistralModel()
+    
+    def _run(self, conversation: list) -> str:
+        """Summarize conversation history"""
+        prompt = f"""
+        Summarize this coaching conversation:
+        {conversation}
+        
+        Include:
+        1. Main concerns discussed
+        2. Key insights shared
+        3. Progress made
+        4. Next steps suggested
+        
+        Keep it concise but meaningful.
+        """
+        
+        return self.model.generate(prompt, max_length=200)

agents/tools/validation_tools.py

@@ -0,0 +1,397 @@
+"""
+Response validation tools for ensuring safe and appropriate responses
+"""
+
+import re
+from typing import Dict, List, Tuple, Optional, Any
+from dataclasses import dataclass
+import json
+from transformers import pipeline
+import torch
+
+@dataclass
+class ValidationResult:
+    """Result of validation check"""
+    is_valid: bool
+    issues: List[str]
+    warnings: List[str]
+    suggestions: List[str]
+    confidence: float
+    refined_text: Optional[str] = None
+
+class ValidationTools:
+    """Tools for validating responses and ensuring safety"""
+    
+    def __init__(self, config):
+        self.config = config
+        
+        # Initialize sentiment analyzer for tone checking
+        self.sentiment_analyzer = pipeline(
+            "sentiment-analysis",
+            model="nlptown/bert-base-multilingual-uncased-sentiment",
+            device=0 if torch.cuda.is_available() else -1
+        )
+        
+        # Prohibited patterns for different categories
+        self.prohibited_patterns = {
+            'medical': [
+                r'\b(?:diagnos|prescrib|medicat|cure|treat|therap)\w*\b',
+                r'\b(?:disease|illness|disorder|syndrome)\s+(?:is|are|can be)\b',
+                r'\b(?:take|consume|dose|dosage)\s+\d+\s*(?:mg|ml|pill|tablet)',
+                r'\b(?:medical|clinical|physician|doctor)\s+(?:advice|consultation|opinion)',
+            ],
+            'legal': [
+                r'\b(?:legal advice|lawsuit|sue|court|litigation)\b',
+                r'\b(?:illegal|unlawful|crime|criminal|prosecut)\w*\b',
+                r'\b(?:you should|must|have to)\s+(?:sign|agree|consent|contract)',
+                r'\b(?:rights|obligations|liability|damages)\s+(?:are|include)\b',
+            ],
+            'financial': [
+                r'\b(?:invest|buy|sell|trade)\s+(?:stock|crypto|bitcoin|forex)\b',
+                r'\b(?:guaranteed|promise)\s+(?:return|profit|income|earnings)\b',
+                r'\b(?:financial advisor|investment advice|trading strategy)\b',
+                r'\b(?:tax|accounting|financial planning)\s+(?:advice|consultation)',
+            ],
+            'harmful': [
+                r'\b(?:suicide|suicidal|kill\s+(?:your|my)self|end\s+(?:it|life))\b',
+                r'\b(?:self[\-\s]?harm|hurt\s+(?:your|my)self|cutting)\b',
+                r'\b(?:violence|violent|weapon|attack|assault)\b',
+                r'\b(?:hate|discriminat|racist|sexist|homophobic)\b',
+            ],
+            'absolute': [
+                r'\b(?:always|never|every|all|none|no one|everyone)\s+(?:will|must|should|is|are)\b',
+                r'\b(?:definitely|certainly|guaranteed|assured|promise)\b',
+                r'\b(?:only way|only solution|must do|have to)\b',
+            ]
+        }
+        
+        # Required elements for supportive responses
+        self.supportive_elements = {
+            'empathy': [
+                'understand', 'hear', 'feel', 'acknowledge', 'recognize',
+                'appreciate', 'empathize', 'relate', 'comprehend'
+            ],
+            'validation': [
+                'valid', 'normal', 'understandable', 'natural', 'okay',
+                'reasonable', 'makes sense', 'legitimate'
+            ],
+            'support': [
+                'support', 'help', 'here for you', 'together', 'alongside',
+                'assist', 'guide', 'accompany', 'with you'
+            ],
+            'hope': [
+                'can', 'possible', 'able', 'capable', 'potential',
+                'opportunity', 'growth', 'improve', 'better', 'progress'
+            ],
+            'empowerment': [
+                'choice', 'decide', 'control', 'power', 'strength',
+                'agency', 'capable', 'resource', 'ability'
+            ]
+        }
+        
+        # Crisis indicators
+        self.crisis_indicators = [
+            r'\b(?:want|going|plan)\s+to\s+(?:die|kill|end)\b',
+            r'\b(?:no reason|point|hope)\s+(?:to|in)\s+(?:live|living|life)\b',
+            r'\b(?:better off|world)\s+without\s+me\b',
+            r'\bsuicide\s+(?:plan|method|attempt)\b',
+            r'\b(?:final|last)\s+(?:goodbye|letter|message)\b'
+        ]
+        
+        # Tone indicators
+        self.negative_tone_words = [
+            'stupid', 'idiot', 'dumb', 'pathetic', 'worthless',
+            'loser', 'failure', 'weak', 'incompetent', 'useless'
+        ]
+        
+        self.dismissive_phrases = [
+            'just get over it', 'stop complaining', 'not a big deal',
+            'being dramatic', 'overreacting', 'too sensitive'
+        ]
+    
+    def validate_response(self, response: str, context: Dict[str, Any] = None) -> ValidationResult:
+        """Comprehensive validation of response"""
+        issues = []
+        warnings = []
+        suggestions = []
+        
+        # Check for prohibited content
+        prohibited_check = self._check_prohibited_content(response)
+        if prohibited_check["found"]:
+            issues.extend(prohibited_check["violations"])
+            suggestions.extend(prohibited_check["suggestions"])
+        
+        # Check tone and sentiment
+        tone_check = self._check_tone(response)
+        if not tone_check["appropriate"]:
+            warnings.extend(tone_check["issues"])
+            suggestions.extend(tone_check["suggestions"])
+        
+        # Check for supportive elements
+        support_check = self._check_supportive_elements(response)
+        if support_check["missing"]:
+            warnings.append(f"Missing supportive elements: {', '.join(support_check['missing'])}")
+            suggestions.extend(support_check["suggestions"])
+        
+        # Check for crisis content in context
+        if context and context.get("user_input"):
+            crisis_check = self._check_crisis_indicators(context["user_input"])
+            if crisis_check["is_crisis"] and "crisis" not in response.lower():
+                warnings.append("User may be in crisis but response doesn't address this")
+                suggestions.append("Include crisis resources and immediate support options")
+        
+        # Calculate overall confidence
+        confidence = self._calculate_confidence(issues, warnings)
+        
+        # Generate refined response if needed
+        refined_text = None
+        if issues or (warnings and confidence < 0.7):
+            refined_text = self._refine_response(response, issues, warnings, suggestions)
+        
+        return ValidationResult(
+            is_valid=len(issues) == 0,
+            issues=issues,
+            warnings=warnings,
+            suggestions=suggestions,
+            confidence=confidence,
+            refined_text=refined_text
+        )
+    
+    def _check_prohibited_content(self, text: str) -> Dict[str, Any]:
+        """Check for prohibited content patterns"""
+        found_violations = []
+        suggestions = []
+        
+        for category, patterns in self.prohibited_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern, text, re.IGNORECASE):
+                    found_violations.append(f"Contains {category} advice/content")
+                    
+                    # Add specific suggestions
+                    if category == "medical":
+                        suggestions.append("Replace with: 'Consider speaking with a healthcare professional'")
+                    elif category == "legal":
+                        suggestions.append("Replace with: 'For legal matters, consult with a qualified attorney'")
+                    elif category == "financial":
+                        suggestions.append("Replace with: 'For financial decisions, consider consulting a financial advisor'")
+                    elif category == "harmful":
+                        suggestions.append("Include crisis resources and express immediate concern for safety")
+                    elif category == "absolute":
+                        suggestions.append("Use qualifying language like 'often', 'might', 'could' instead of absolutes")
+                    break
+        
+        return {
+            "found": len(found_violations) > 0,
+            "violations": found_violations,
+            "suggestions": suggestions
+        }
+    
+    def _check_tone(self, text: str) -> Dict[str, Any]:
+        """Check the tone and sentiment of the response"""
+        issues = []
+        suggestions = []
+        
+        # Check sentiment
+        try:
+            sentiment_result = self.sentiment_analyzer(text[:512])[0]  # Limit length for model
+            sentiment_score = sentiment_result['score']
+            sentiment_label = sentiment_result['label']
+            
+            # Check if too negative
+            if '1' in sentiment_label or '2' in sentiment_label:  # 1-2 stars = negative
+                issues.append("Response tone is too negative")
+                suggestions.append("Add more supportive and hopeful language")
+        except:
+            pass
+        
+        # Check for negative words
+        text_lower = text.lower()
+        found_negative = [word for word in self.negative_tone_words if word in text_lower]
+        if found_negative:
+            issues.append(f"Contains negative/judgmental language: {', '.join(found_negative)}")
+            suggestions.append("Replace judgmental terms with supportive language")
+        
+        # Check for dismissive phrases
+        found_dismissive = [phrase for phrase in self.dismissive_phrases if phrase in text_lower]
+        if found_dismissive:
+            issues.append("Contains dismissive language")
+            suggestions.append("Acknowledge and validate the person's feelings instead")
+        
+        return {
+            "appropriate": len(issues) == 0,
+            "issues": issues,
+            "suggestions": suggestions
+        }
+    
+    def _check_supportive_elements(self, text: str) -> Dict[str, Any]:
+        """Check for presence of supportive elements"""
+        text_lower = text.lower()
+        missing_elements = []
+        suggestions = []
+        
+        element_scores = {}
+        for element, keywords in self.supportive_elements.items():
+            found = any(keyword in text_lower for keyword in keywords)
+            element_scores[element] = found
+            if not found:
+                missing_elements.append(element)
+        
+        # Generate suggestions for missing elements
+        if 'empathy' in missing_elements:
+            suggestions.append("Add empathetic language like 'I understand how difficult this must be'")
+        if 'validation' in missing_elements:
+            suggestions.append("Validate their feelings with phrases like 'Your feelings are completely valid'")
+        if 'support' in missing_elements:
+            suggestions.append("Express support with 'I'm here to support you through this'")
+        if 'hope' in missing_elements:
+            suggestions.append("Include hopeful elements about growth and positive change")
+        if 'empowerment' in missing_elements:
+            suggestions.append("Emphasize their agency and ability to make choices")
+        
+        return {
+            "missing": missing_elements,
+            "present": [k for k, v in element_scores.items() if v],
+            "suggestions": suggestions
+        }
+    
+    def _check_crisis_indicators(self, text: str) -> Dict[str, Any]:
+        """Check for crisis indicators in text"""
+        for pattern in self.crisis_indicators:
+            if re.search(pattern, text, re.IGNORECASE):
+                return {
+                    "is_crisis": True,
+                    "pattern_matched": pattern,
+                    "action": "Immediate crisis response needed"
+                }
+        
+        return {"is_crisis": False}
+    
+    def _calculate_confidence(self, issues: List[str], warnings: List[str]) -> float:
+        """Calculate confidence score for validation"""
+        if issues:
+            return 0.3 - (0.1 * len(issues))  # Major issues severely impact confidence
+        
+        confidence = 1.0
+        confidence -= 0.1 * len(warnings)  # Each warning reduces confidence
+        
+        return max(0.0, confidence)
+    
+    def _refine_response(self, response: str, issues: List[str], warnings: List[str], suggestions: List[str]) -> str:
+        """Attempt to refine the response based on issues found"""
+        refined = response
+        
+        # Add disclaimer for professional advice
+        if any('advice' in issue for issue in issues):
+            disclaimer = "\n\n*Please note: I'm here to provide support and guidance, but for specific professional matters, it's important to consult with qualified professionals.*"
+            if disclaimer not in refined:
+                refined += disclaimer
+        
+        # Add crisis resources if needed
+        if any('crisis' in warning for warning in warnings):
+            crisis_text = "\n\n**If you're in crisis, please reach out for immediate help:**\n- Crisis Hotline: 988 (US)\n- Crisis Text Line: Text HOME to 741741\n- International: findahelpline.com"
+            if crisis_text not in refined:
+                refined += crisis_text
+        
+        # Add supportive closing if missing hope
+        if any('hope' in warning for warning in warnings):
+            hopeful_closing = "\n\nRemember, you have the strength to navigate this challenge, and positive change is possible. I'm here to support you on this journey."
+            if not any(phrase in refined.lower() for phrase in ['journey', 'strength', 'possible']):
+                refined += hopeful_closing
+        
+        return refined
+    
+    def validate_user_input(self, text: str) -> ValidationResult:
+        """Validate user input for safety and process-ability"""
+        issues = []
+        warnings = []
+        suggestions = []
+        
+        # Check if empty
+        if not text or not text.strip():
+            issues.append("Empty input received")
+            suggestions.append("Please share what's on your mind")
+            return ValidationResult(False, issues, warnings, suggestions, 0.0)
+        
+        # Check length
+        if len(text) > 5000:
+            warnings.append("Input is very long")
+            suggestions.append("Consider breaking this into smaller parts")
+        
+        # Check for crisis indicators
+        crisis_check = self._check_crisis_indicators(text)
+        if crisis_check["is_crisis"]:
+            warnings.append("Crisis indicators detected")
+            suggestions.append("Prioritize safety and provide crisis resources")
+        
+        # Check for spam/repetition
+        if self._is_spam(text):
+            issues.append("Input appears to be spam or repetitive")
+            suggestions.append("Please share genuine thoughts or concerns")
+        
+        confidence = self._calculate_confidence(issues, warnings)
+        
+        return ValidationResult(
+            is_valid=len(issues) == 0,
+            issues=issues,
+            warnings=warnings,
+            suggestions=suggestions,
+            confidence=confidence
+        )
+    
+    def _is_spam(self, text: str) -> bool:
+        """Simple spam detection"""
+        # Check for excessive repetition
+        words = text.lower().split()
+        if len(words) > 10:
+            unique_ratio = len(set(words)) / len(words)
+            if unique_ratio < 0.3:  # Less than 30% unique words
+                return True
+        
+        # Check for common spam patterns
+        spam_patterns = [
+            r'(?:buy|sell|click|visit)\s+(?:now|here|this)',
+            r'(?:congratulations|winner|prize|lottery)',
+            r'(?:viagra|pills|drugs|pharmacy)',
+            r'(?:$$|money\s+back|guarantee)'
+        ]
+        
+        for pattern in spam_patterns:
+            if re.search(pattern, text, re.IGNORECASE):
+                return True
+        
+        return False
+    
+    def get_crisis_resources(self, location: str = "global") -> Dict[str, Any]:
+        """Get crisis resources based on location"""
+        resources = {
+            "global": {
+                "name": "International Association for Suicide Prevention",
+                "url": "https://www.iasp.info/resources/Crisis_Centres/",
+                "text": "Find crisis centers worldwide"
+            },
+            "us": {
+                "name": "988 Suicide & Crisis Lifeline",
+                "phone": "988",
+                "text": "Text HOME to 741741",
+                "url": "https://988lifeline.org/"
+            },
+            "uk": {
+                "name": "Samaritans",
+                "phone": "116 123",
+                "email": "jo@samaritans.org",
+                "url": "https://www.samaritans.org/"
+            },
+            "india": {
+                "name": "National Suicide Prevention Helpline",
+                "phone": "91-9820466726",
+                "additional": "Vandrevala Foundation: 9999666555"
+            },
+            "australia": {
+                "name": "Lifeline",
+                "phone": "13 11 14",
+                "text": "Text 0477 13 11 14",
+                "url": "https://www.lifeline.org.au/"
+            }
+        }
+        
+        return resources.get(location.lower(), resources["global"])

agents/tools/voice_tools.py

@@ -0,0 +1,93 @@
+import os
+import numpy as np
+import torch
+from transformers import pipeline, AutoProcessor, AutoModelForSpeechSeq2Seq
+import asyncio
+import soundfile as sf
+import tempfile  # Added the import for tempfile!
+from models.mistral_model import MistralModel
+
+class MultilingualVoiceProcessor:
+    def __init__(self, model_name="openai/whisper-base", device=None):
+        cache_dir = os.getenv("TRANSFORMERS_CACHE", None)
+        if device is None:
+            device = 0 if torch.cuda.is_available() else -1
+        
+        # Load model and processor with cache_dir
+        processor = AutoProcessor.from_pretrained(model_name, cache_dir=cache_dir)
+        model = AutoModelForSpeechSeq2Seq.from_pretrained(model_name, cache_dir=cache_dir)
+
+        # Create the pipeline, DO NOT PASS cache_dir here
+        self.pipe = pipeline(
+            "automatic-speech-recognition",
+            model=model,
+            tokenizer=processor,
+            feature_extractor=processor,
+            device=device,
+            generate_kwargs={"task": "transcribe", "return_timestamps": False},
+        )
+
+    async def transcribe(self, audio_data: np.ndarray, language: str = None):
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as tmp_wav:
+            sf.write(tmp_wav.name, audio_data, samplerate=16000)
+            extra = {"language": language} if language else {}
+            result = self.pipe(tmp_wav.name, **extra)
+        text = result['text']
+        return text, language or "unknown"
+
+    async def synthesize(self, text, language: str = "en", voice_type: str = "normal"):
+        raise NotImplementedError("Use gTTS or edge-tts as before.")
+
+class VoiceTools:
+    def __init__(self, config=None):
+        self.config = config
+        self.vp = MultilingualVoiceProcessor()
+
+    def transcribe_audio(self, audio_data: np.ndarray, language=None):
+        text, detected_lang = asyncio.run(self.vp.transcribe(audio_data, language))
+        return {"text": text, "language": detected_lang}
+
+    def detect_emotion(self, text: str) -> dict:
+        model = MistralModel()
+        prompt = f"""
+        Analyze the emotional state in this text: "{text}"
+        Identify:
+        1. Primary emotion (joy, sadness, anger, fear, anxiety, confusion, etc.)
+        2. Emotional intensity (low, medium, high)
+        3. Underlying feelings
+        4. Key concerns
+        Format as JSON with keys: primary_emotion, intensity, feelings, concerns
+        """
+        response = model.generate(prompt)
+        # TODO: Actually parse response, dummy return for now:
+        return {
+            "primary_emotion": "detected_emotion",
+            "intensity": "medium",
+            "feelings": ["feeling1", "feeling2"],
+            "concerns": ["concern1", "concern2"]
+        }
+
+    def generate_reflective_questions(self, context: dict) -> list:
+        emotion = context.get("primary_emotion", "neutral")
+        questions_map = {
+            "anxiety": [
+                "What specific thoughts are creating this anxiety?",
+                "What would feeling calm look like in this situation?",
+                "What has helped you manage anxiety before?"
+            ],
+            "sadness": [
+                "What would comfort mean to you right now?",
+                "What are you grieving or missing?",
+                "How can you be gentle with yourself today?"
+            ],
+            "confusion": [
+                "What would clarity feel like?",
+                "What's the main question you're grappling with?",
+                "What does your intuition tell you?"
+            ]
+        }
+        return questions_map.get(emotion, [
+            "How are you feeling in this moment?",
+            "What would support look like for you?",
+            "What's most important to explore right now?"
+        ])

agents/tools/voice_tools_old.py

@@ -0,0 +1,194 @@
+"""
+Multilingual Voice Processing Tools
+STT and TTS with language support
+"""
+
+import whisper
+import numpy as np
+from gtts import gTTS
+import edge_tts
+import io
+import asyncio
+from typing import Tuple, Optional
+from crewai.tools import BaseTool
+import speech_recognition as sr
+
+class MultilingualVoiceProcessor:
+    """Handles multilingual STT and TTS"""
+    
+    def __init__(self):
+        # Load Whisper model for multilingual STT
+        self.whisper_model = whisper.load_model("base")
+        
+        # Language voice mappings for Edge TTS
+        self.voice_map = {
+            "en": "en-US-AriaNeural",
+            "es": "es-ES-ElviraNeural",
+            "fr": "fr-FR-DeniseNeural",
+            "de": "de-DE-KatjaNeural",
+            "it": "it-IT-ElsaNeural",
+            "pt": "pt-BR-FranciscaNeural",
+            "hi": "hi-IN-SwaraNeural",
+            "zh": "zh-CN-XiaoxiaoNeural",
+            "ja": "ja-JP-NanamiNeural",
+            "ko": "ko-KR-SunHiNeural",
+            "ar": "ar-SA-ZariyahNeural",
+            "ru": "ru-RU-SvetlanaNeural"
+        }
+    
+    async def transcribe(
+        self, 
+        audio_data: np.ndarray, 
+        language: Optional[str] = None
+    ) -> Tuple[str, str]:
+        """Transcribe audio to text with language detection"""
+        try:
+            # Process audio
+            if isinstance(audio_data, tuple):
+                sample_rate, audio = audio_data
+            else:
+                audio = audio_data
+                sample_rate = 16000
+            
+            # Normalize audio
+            if audio.dtype != np.float32:
+                audio = audio.astype(np.float32) / 32768.0
+            
+            # Transcribe with Whisper
+            if language and language != "auto":
+                result = self.whisper_model.transcribe(
+                    audio, 
+                    language=language
+                )
+            else:
+                # Auto-detect language
+                result = self.whisper_model.transcribe(audio)
+            
+            text = result["text"]
+            detected_language = result["language"]
+            
+            return text, detected_language
+            
+        except Exception as e:
+            print(f"Transcription error: {e}")
+            return "Could not transcribe audio", "en"
+    
+    async def synthesize(
+        self, 
+        text: str, 
+        language: str = "en",
+        voice_type: str = "normal"
+    ) -> bytes:
+        """Convert text to speech with voice modulation"""
+        try:
+            voice = self.voice_map.get(language, "en-US-AriaNeural")
+            
+            # Apply voice settings for meditation tone
+            if voice_type == "meditation":
+                rate = "-15%"  # Slower
+                pitch = "-50Hz"  # Lower pitch
+            else:
+                rate = "+0%"
+                pitch = "+0Hz"
+            
+            # Generate speech
+            communicate = edge_tts.Communicate(
+                text,
+                voice,
+                rate=rate,
+                pitch=pitch
+            )
+            
+            audio_data = b""
+            async for chunk in communicate.stream():
+                if chunk["type"] == "audio":
+                    audio_data += chunk["data"]
+            
+            return audio_data
+            
+        except Exception as e:
+            print(f"TTS error: {e}")
+            # Fallback to gTTS
+            try:
+                tts = gTTS(text=text, lang=language[:2])
+                fp = io.BytesIO()
+                tts.write_to_fp(fp)
+                return fp.getvalue()
+            except:
+                return None
+
+class TranscribeTool(BaseTool):
+    name: str = "transcribe_audio"
+    description: str = "Transcribe audio input to text with language detection"
+    
+    def _run(self, audio_data: np.ndarray, language: str = None) -> dict:
+        processor = MultilingualVoiceProcessor()
+        text, detected_lang = asyncio.run(
+            processor.transcribe(audio_data, language)
+        )
+        return {
+            "text": text,
+            "language": detected_lang
+        }
+
+class DetectEmotionTool(BaseTool):
+    name: str = "detect_emotion"
+    description: str = "Detect emotional state from text using Mistral"
+    
+    def _run(self, text: str) -> dict:
+        # Use Mistral for emotion detection
+        from models.mistral_model import MistralModel
+        model = MistralModel()
+        
+        prompt = f"""
+        Analyze the emotional state in this text: "{text}"
+        
+        Identify:
+        1. Primary emotion (joy, sadness, anger, fear, anxiety, confusion, etc.)
+        2. Emotional intensity (low, medium, high)
+        3. Underlying feelings
+        4. Key concerns
+        
+        Format as JSON with keys: primary_emotion, intensity, feelings, concerns
+        """
+        
+        response = model.generate(prompt)
+        
+        # Parse response (simplified)
+        return {
+            "primary_emotion": "detected_emotion",
+            "intensity": "medium",
+            "feelings": ["feeling1", "feeling2"],
+            "concerns": ["concern1", "concern2"]
+        }
+
+class GenerateQuestionsTool(BaseTool):
+    name: str = "generate_reflective_questions"
+    description: str = "Generate empathetic reflective questions"
+    
+    def _run(self, context: dict) -> list:
+        emotion = context.get("primary_emotion", "neutral")
+        
+        questions_map = {
+            "anxiety": [
+                "What specific thoughts are creating this anxiety?",
+                "What would feeling calm look like in this situation?",
+                "What has helped you manage anxiety before?"
+            ],
+            "sadness": [
+                "What would comfort mean to you right now?",
+                "What are you grieving or missing?",
+                "How can you be gentle with yourself today?"
+            ],
+            "confusion": [
+                "What would clarity feel like?",
+                "What's the main question you're grappling with?",
+                "What does your intuition tell you?"
+            ]
+        }
+        
+        return questions_map.get(emotion, [
+            "How are you feeling in this moment?",
+            "What would support look like for you?",
+            "What's most important to explore right now?"
+        ])

agents/tools/voice_tools_openaiwhisper.py

@@ -0,0 +1,181 @@
+"""
+Multilingual Voice Processing Tools - modular class version
+"""
+import numpy as np
+import asyncio
+from models.mistral_model import MistralModel
+import whisper
+import numpy as np
+from gtts import gTTS
+import edge_tts
+import io
+import asyncio
+from typing import Tuple, Optional
+#from crewai.tools import BaseTool
+import speech_recognition as sr
+from transformers import pipeline
+import whisper
+
+# class MultilingualVoiceProcessor:
+#     """Handles multilingual STT and TTS"""
+    
+#     def __init__(self):
+#         # Load Whisper model for multilingual STT
+#         self.whisper_model = whisper.load_model("base")
+        
+#         # Language voice mappings for Edge TTS
+#         self.voice_map = {
+#             "en": "en-US-AriaNeural",
+#             "es": "es-ES-ElviraNeural",
+#             "fr": "fr-FR-DeniseNeural",
+#             "de": "de-DE-KatjaNeural",
+#             "it": "it-IT-ElsaNeural",
+#             "pt": "pt-BR-FranciscaNeural",
+#             "hi": "hi-IN-SwaraNeural",
+#             "zh": "zh-CN-XiaoxiaoNeural",
+#             "ja": "ja-JP-NanamiNeural",
+#             "ko": "ko-KR-SunHiNeural",
+#             "ar": "ar-SA-ZariyahNeural",
+#             "ru": "ru-RU-SvetlanaNeural"
+#         }
+    
+#     async def transcribe(
+#         self, 
+#         audio_data: np.ndarray, 
+#         language: Optional[str] = None
+#     ) -> Tuple[str, str]:
+#         """Transcribe audio to text with language detection"""
+#         try:
+#             # Process audio
+#             if isinstance(audio_data, tuple):
+#                 sample_rate, audio = audio_data
+#             else:
+#                 audio = audio_data
+#                 sample_rate = 16000
+            
+#             # Normalize audio
+#             if audio.dtype != np.float32:
+#                 audio = audio.astype(np.float32) / 32768.0
+            
+#             # Transcribe with Whisper
+#             if language and language != "auto":
+#                 result = self.whisper_model.transcribe(
+#                     audio, 
+#                     language=language
+#                 )
+#             else:
+#                 # Auto-detect language
+#                 result = self.whisper_model.transcribe(audio)
+            
+#             text = result["text"]
+#             detected_language = result["language"]
+            
+#             return text, detected_language
+            
+#         except Exception as e:
+#             print(f"Transcription error: {e}")
+#             return "Could not transcribe audio", "en"
+    
+#     async def synthesize(
+#         self, 
+#         text: str, 
+#         language: str = "en",
+#         voice_type: str = "normal"
+#     ) -> bytes:
+#         """Convert text to speech with voice modulation"""
+#         try:
+#             voice = self.voice_map.get(language, "en-US-AriaNeural")
+            
+#             # Apply voice settings for meditation tone
+#             if voice_type == "meditation":
+#                 rate = "-15%"  # Slower
+#                 pitch = "-50Hz"  # Lower pitch
+#             else:
+#                 rate = "+0%"
+#                 pitch = "+0Hz"
+            
+#             # Generate speech
+#             communicate = edge_tts.Communicate(
+#                 text,
+#                 voice,
+#                 rate=rate,
+#                 pitch=pitch
+#             )
+            
+#             audio_data = b""
+#             async for chunk in communicate.stream():
+#                 if chunk["type"] == "audio":
+#                     audio_data += chunk["data"]
+            
+#             return audio_data
+            
+#         except Exception as e:
+#             print(f"TTS error: {e}")
+#             # Fallback to gTTS
+#             try:
+#                 tts = gTTS(text=text, lang=language[:2])
+#                 fp = io.BytesIO()
+#                 tts.write_to_fp(fp)
+#                 return fp.getvalue()
+#             except:
+#                 return None
+
+
+class VoiceTools:
+    def __init__(self, config=None):
+        self.config = config
+        self.vp = MultilingualVoiceProcessor()
+
+    def transcribe_audio(self, audio_data: np.ndarray, language=None) -> dict:
+        """Transcribe audio to text with language detection."""
+        text, detected_lang = asyncio.run(
+            self.vp.transcribe(audio_data, language)
+        )
+        return {"text": text, "language": detected_lang}
+
+    def detect_emotion(self, text: str) -> dict:
+        """Detect emotional state from text using LLM."""
+        model = MistralModel()
+        prompt = f"""
+        Analyze the emotional state in this text: "{text}"
+        Identify:
+        1. Primary emotion (joy, sadness, anger, fear, anxiety, confusion, etc.)
+        2. Emotional intensity (low, medium, high)
+        3. Underlying feelings
+        4. Key concerns
+        Format as JSON with keys: primary_emotion, intensity, feelings, concerns
+        """
+        response = model.generate(prompt)
+        # Ideally: parse LLM's response, for now, stubbed:
+        return {
+            "primary_emotion": "detected_emotion",
+            "intensity": "medium",
+            "feelings": ["feeling1", "feeling2"],
+            "concerns": ["concern1", "concern2"]
+        }
+
+    def generate_reflective_questions(self, context: dict) -> list:
+        """Generate empathetic reflective questions."""
+        emotion = context.get("primary_emotion", "neutral")
+        questions_map = {
+            "anxiety": [
+                "What specific thoughts are creating this anxiety?",
+                "What would feeling calm look like in this situation?",
+                "What has helped you manage anxiety before?"
+            ],
+            "sadness": [
+                "What would comfort mean to you right now?",
+                "What are you grieving or missing?",
+                "How can you be gentle with yourself today?"
+            ],
+            "confusion": [
+                "What would clarity feel like?",
+                "What's the main question you're grappling with?",
+                "What does your intuition tell you?"
+            ]
+        }
+        return questions_map.get(emotion, [
+            "How are you feeling in this moment?",
+            "What would support look like for you?",
+            "What's most important to explore right now?"
+        ])

app.py

@@ -0,0 +1,259 @@
+"""
+Personal AI Coach with CrewAI and Mistral
+Multilingual support with advanced conversational AI
+"""
+
+import gradio as gr
+import asyncio
+import os
+import sys
+from datetime import datetime
+from typing import Dict, List, Tuple, Optional
+import numpy as np
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from crew_config import PersonalCoachCrew
+from agents.tools.voice_tools import MultilingualVoiceProcessor
+from utils.config import Config
+from dotenv import load_dotenv
+import certifi
+load_dotenv()
+
+class PersonalCoachApp:
+    """Main application using CrewAI orchestration"""
+    
+    def __init__(self):
+        print("Initializing Personal Coach AI with CrewAI...")
+        self.config = Config()
+        
+        # Initialize CrewAI
+        self.crew = PersonalCoachCrew(self.config)
+        
+        # Initialize voice processor
+        self.voice_processor = MultilingualVoiceProcessor()
+        
+        # Session management
+        self.conversation_history = []
+        self.session_data = {
+            "start_time": datetime.now(),
+            "language": "en",
+            "user_profile": {}
+        }
+        
+        print("Personal Coach AI initialized successfully!")
+    
+    async def process_input(
+        self, 
+        text_input: str, 
+        voice_input: Optional[np.ndarray], 
+        language: str,
+        history: List
+    ) -> Tuple:
+        """Process user input through CrewAI"""
+        try:
+            # Prepare input data
+            if voice_input is not None:
+                # Process voice input with language detection
+                transcribed_text, detected_lang = await self.voice_processor.transcribe(
+                    voice_input, 
+                    language
+                )
+                text_input = transcribed_text
+                self.session_data["language"] = detected_lang
+            else:
+                self.session_data["language"] = language
+            
+            if not text_input:
+                return history, None, "", None
+            
+            # Prepare crew input
+            crew_input = {
+                "user_message": text_input,
+                "language": self.session_data["language"],
+                "conversation_history": history[-5:],  # Last 5 exchanges
+                "user_profile": self.session_data.get("user_profile", {})
+            }
+            
+            # Execute crew
+            print(f"Processing input in {self.session_data['language']}...")
+            result = self.crew.kickoff(inputs=crew_input)
+            
+            # Extract response
+            response_text = result.get("final_response", "I'm here to help. Please tell me more.")
+            
+            # Generate audio response
+            audio_response = await self.voice_processor.synthesize(
+                response_text,
+                self.session_data["language"],
+                voice_type="meditation"
+            )
+            
+            # Update history
+            history.append([text_input, response_text])
+            
+            # Update user profile
+            if "user_profile_update" in result:
+                self.session_data["user_profile"].update(result["user_profile_update"])
+            
+            return history, audio_response, "", None
+            
+        except Exception as e:
+            print(f"Error in process_input: {str(e)}")
+            error_message = f"I apologize, but I encountered an error: {str(e)}"
+            history.append(["Error", error_message])
+            return history, None, "", None
+    
+    def clear_conversation(self):
+        """Clear conversation and reset session"""
+        self.conversation_history = []
+        self.session_data["user_profile"] = {}
+        return [], None
+
+def create_interface():
+    """Create Gradio interface with multilingual support"""
+    app = PersonalCoachApp()
+    
+    with gr.Blocks(theme=gr.themes.Soft(), title="Personal AI Coach") as interface:
+        gr.Markdown("""
+        # 🧘 Personal AI Coach - Multilingual CrewAI System
+        
+        Powered by Mistral AI and CrewAI's multi-agent framework. Supports multiple languages!
+        
+        **Features:**
+        - 🌍 Multilingual voice and text support
+        - 🤖 4 specialized AI agents working together
+        - 🧠 Advanced Mistral AI for deep understanding
+        - 📚 Wisdom from 13 spiritual and self-help texts
+        - 🎙️ Natural voice interactions in your language
+        """)
+        
+        with gr.Row():
+            # Main chat interface
+            with gr.Column(scale=3):
+                chatbot = gr.Chatbot(
+                    height=500,
+                    bubble_full_width=False,
+                    avatar_images=(None, "🧘")
+                )
+                
+                with gr.Row():
+                    language = gr.Dropdown(
+                        choices=[
+                            ("English", "en"),
+                            ("Spanish", "es"),
+                            ("French", "fr"),
+                            ("German", "de"),
+                            ("Italian", "it"),
+                            ("Portuguese", "pt"),
+                            ("Hindi", "hi"),
+                            ("Chinese", "zh"),
+                            ("Japanese", "ja"),
+                            ("Korean", "ko"),
+                            ("Arabic", "ar"),
+                            ("Russian", "ru")
+                        ],
+                        value="en",
+                        label="Language",
+                        scale=1
+                    )
+                    
+                    text_input = gr.Textbox(
+                        placeholder="Type your message or click the microphone...",
+                        show_label=False,
+                        scale=3
+                    )
+                    
+                    voice_input = gr.Audio(
+                        source="microphone",
+                        type="numpy",
+                        label="🎤",
+                        scale=1
+                    )
+                
+                with gr.Row():
+                    send_btn = gr.Button("Send 📤", variant="primary")
+                    clear_btn = gr.Button("Clear 🗑️")
+                
+                audio_output = gr.Audio(
+                    label="🔊 Coach Response",
+                    autoplay=True
+                )
+            
+            # Sidebar
+            with gr.Column(scale=1):
+                gr.Markdown("""
+                ### 🤖 CrewAI Agent Team
+                
+                **Agent 1: Empathetic Listener**
+                - Multilingual voice processing
+                - Emotional understanding
+                - Context analysis
+                
+                **Agent 2: Wisdom Keeper**
+                - RAG with Mistral AI
+                - Spiritual text knowledge
+                - Personalized guidance
+                
+                **Agent 3: Guardian**
+                - Response validation
+                - Safety checks
+                - Tone refinement
+                
+                **Agent 4: Conversation Guide**
+                - Natural dialogue flow
+                - Voice synthesis
+                - Feedback integration
+                
+                ### 🌍 Supported Languages
+                Voice input/output in 12+ languages
+                
+                ### 📚 Knowledge Sources
+                - Bhagavad Gita
+                - Power of Now
+                - Atomic Habits
+                - Meditations
+                - And 9 more texts...
+                """)
+        
+        # Examples in multiple languages
+        with gr.Accordion("💡 Example Prompts", open=False):
+            gr.Examples(
+                examples=[
+                    ["I'm feeling overwhelmed with work pressure", "en"],
+                    ["Je me sens perdu dans ma vie", "fr"],
+                    ["Estoy luchando con la ansiedad", "es"],
+                    ["Ich möchte bessere Gewohnheiten aufbauen", "de"],
+                    ["मुझे अपने जीवन का उद्देश्य नहीं मिल रहा", "hi"],
+                    ["我想学习冥想", "zh"]
+                ],
+                inputs=[text_input, language]
+            )
+        
+        # Event handlers
+        async def handle_submission(text, voice, lang, history):
+            return await app.process_input(text, voice, lang, history)
+        
+        # Connect events
+        for trigger in [text_input.submit, send_btn.click]:
+            trigger(
+                fn=lambda *args: asyncio.run(handle_submission(*args)),
+                inputs=[text_input, voice_input, language, chatbot],
+                outputs=[chatbot, audio_output, text_input, voice_input]
+            )
+        
+        clear_btn.click(
+            fn=app.clear_conversation,
+            outputs=[chatbot, audio_output]
+        )
+    
+    return interface
+
+if __name__ == "__main__":
+    print("Starting Personal Coach AI with CrewAI...")
+    interface = create_interface()
+    interface.launch(
+        server_name="127.0.0.1",
+        server_port=7860,
+        share=False
+    )

crew_config.py

@@ -0,0 +1,73 @@
+from agents.tools.voice_tools import VoiceTools
+from agents.tools.llm_tools import LLMTools
+from agents.tools.knowledge_tools import KnowledgeTools
+from agents.tools.validation_tools import ValidationTools
+from crewai import Agent
+from utils.knowledge_base import KnowledgeBase
+
+class PersonalCoachCrew:
+    def __init__(self, config):
+        self.config = config 
+        # Centralized tool instances
+        self.voice_tools = VoiceTools(self.config)
+        self.llm_tools = LLMTools(self.config)
+        self.knowledge_tools = KnowledgeTools(self.config)
+        self.validation_tools = ValidationTools(self.config)
+
+        self.knowledge_base = KnowledgeBase(self.config)
+        self._initialize_agents()
+        self._create_crew()
+
+    def _initialize_agents(self):
+        # ----- AGENT 1 -----
+        self.conversation_handler = Agent(
+            role="Empathetic Conversation Handler",
+            goal="Understand user's emotional state and needs through compassionate dialogue",
+            backstory="...",
+            verbose=self.config.crew.verbose,
+            allow_delegation=False,
+            tools=[
+                self.voice_tools.transcribe_audio,
+                self.voice_tools.detect_emotion,
+                self.voice_tools.generate_reflective_questions,
+            ]
+        )
+        # ----- AGENT 2 -----
+        self.wisdom_advisor = Agent(
+            role="Wisdom Keeper and Spiritual Guide",
+            goal="Provide personalized guidance drawing from ancient wisdom and modern psychology",
+            backstory="...",
+            verbose=self.config.crew.verbose,
+            allow_delegation=False,
+            tools=[
+                self.knowledge_tools.search_knowledge,
+                self.knowledge_tools.extract_wisdom,
+                self.knowledge_tools.suggest_practices,
+                self.llm_tools.mistral_chat,
+                self.llm_tools.generate_advice,
+            ]
+        )
+        # ----- AGENT 3 -----
+        self.response_validator = Agent(
+            role="Response Guardian and Quality Validator",
+            goal="Ensure all responses are safe, appropriate, and truly helpful",
+            backstory="...",
+            verbose=self.config.crew.verbose,
+            allow_delegation=False,
+            tools=[
+                self.validation_tools.check_safety,
+                self.validation_tools.validate_tone,
+                self.validation_tools.refine_response,
+            ]
+        )
+        # ----- AGENT 4 -----
+        self.interaction_manager = Agent(
+            role="Conversation Flow Manager",
+            goal="Create natural, engaging dialogue that helps users on their journey",
+            backstory="...",
+            verbose=self.config.crew.verbose,
+            allow_delegation=False,
+            tools=[
+                self.llm_tools.summarize_conversation,
+            ]
+        )

data/books/7_habits.txt

@@ -0,0 +1,2 @@
+Placeholder for 7_habits.txt
+Add full text here.

data/books/atomic_habits.txt

@@ -0,0 +1,2 @@
+Placeholder for atomic_habits.txt
+Add full text here.

data/books/autobiography_of_a_yogi.txt

@@ -0,0 +1,2 @@
+Placeholder for autobiography_of_a_yogi.txt
+Add full text here.

data/books/bhagavad_gita.txt

@@ -0,0 +1,2 @@
+Placeholder for bhagavad_gita.txt
+Add full text here.

data/books/dhyana_vahini.txt

@@ -0,0 +1,2 @@
+Placeholder for dhyana_vahini.txt
+Add full text here.

data/books/mans_search_for_meaning.txt

@@ -0,0 +1,2 @@
+Placeholder for mans_search_for_meaning.txt
+Add full text here.

data/books/meditations.txt

@@ -0,0 +1,2 @@
+Placeholder for meditations.txt
+Add full text here.

data/books/mindset.txt

@@ -0,0 +1,2 @@
+Placeholder for mindset.txt
+Add full text here.

data/books/prasnothara_vahini.txt

@@ -0,0 +1,2 @@
+Placeholder for prasnothara_vahini.txt
+Add full text here.

data/books/prema_vahini.txt

@@ -0,0 +1,2 @@
+Placeholder for prema_vahini.txt
+Add full text here.

data/books/tao_te_ching.txt

@@ -0,0 +1,2 @@
+Placeholder for tao_te_ching.txt
+Add full text here.

data/books/the_power_of_now.txt

@@ -0,0 +1,2 @@
+Placeholder for the_power_of_now.txt
+Add full text here.

data/faiss_index/metadata.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36ec600de36710fb9e7741ffe98886792a726651172f48a6e3de392836bbfc68
+size 1402

data/faiss_index/passages.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d637604fad4c72b56e5b7c74280a7804482ce2f27dcb72dad08650cf86c40881
+size 1859

models/_init_.py

@@ -0,0 +1,224 @@
+"""
+Models module for Personal Coach CrewAI Application
+Handles all AI model loading and management
+"""
+
+from typing import TYPE_CHECKING, Optional, Dict, Any
+import torch
+
+# Version info
+__version__ = "1.0.0"
+
+# Lazy imports
+if TYPE_CHECKING:
+    from .mistral_model import MistralModel, MistralConfig, MistralPromptFormatter
+
+# Public API
+__all__ = [
+    # Main model classes
+    "MistralModel",
+    "MistralConfig", 
+    "MistralPromptFormatter",
+    
+    # Model management
+    "load_model",
+    "get_model_info",
+    "clear_model_cache",
+    
+    # Constants
+    "AVAILABLE_MODELS",
+    "MODEL_REQUIREMENTS",
+    "DEFAULT_MODEL_CONFIG"
+]
+
+# Available models
+AVAILABLE_MODELS = {
+    "mistral-7b-instruct": {
+        "model_id": "mistralai/Mistral-7B-Instruct-v0.1",
+        "type": "instruction-following",
+        "size": "7B",
+        "context_length": 32768,
+        "languages": ["multilingual"]
+    },
+    "mistral-7b": {
+        "model_id": "mistralai/Mistral-7B-v0.1",
+        "type": "base",
+        "size": "7B", 
+        "context_length": 32768,
+        "languages": ["multilingual"]
+    }
+}
+
+# Model requirements
+MODEL_REQUIREMENTS = {
+    "mistral-7b-instruct": {
+        "ram": "16GB",
+        "vram": "8GB (GPU) or 16GB (CPU)",
+        "disk": "15GB",
+        "compute": "GPU recommended"
+    }
+}
+
+# Default configuration
+DEFAULT_MODEL_CONFIG = {
+    "max_length": 2048,
+    "temperature": 0.7,
+    "top_p": 0.95,
+    "top_k": 50,
+    "do_sample": True,
+    "num_return_sequences": 1,
+    "device": "cuda" if torch.cuda.is_available() else "cpu",
+    "torch_dtype": torch.float16 if torch.cuda.is_available() else torch.float32,
+    "load_in_8bit": False,
+    "cache_dir": ".cache/models"
+}
+
+# Model instance cache
+_model_cache: Dict[str, Any] = {}
+
+def load_model(model_name: str = "mistral-7b-instruct", config: Optional[Dict[str, Any]] = None):
+    """
+    Load a model with caching support
+    
+    Args:
+        model_name: Name of the model to load
+        config: Optional configuration override
+        
+    Returns:
+        Model instance
+    """
+    # Check cache first
+    cache_key = f"{model_name}_{str(config)}"
+    if cache_key in _model_cache:
+        return _model_cache[cache_key]
+    
+    # Import here to avoid circular imports
+    from .mistral_model import MistralModel, MistralConfig
+    
+    # Get model info
+    model_info = AVAILABLE_MODELS.get(model_name)
+    if not model_info:
+        raise ValueError(f"Unknown model: {model_name}")
+    
+    # Merge configurations
+    model_config = DEFAULT_MODEL_CONFIG.copy()
+    if config:
+        model_config.update(config)
+    
+    # Create config object
+    mistral_config = MistralConfig(
+        model_id=model_info["model_id"],
+        **model_config
+    )
+    
+    # Load model
+    model = MistralModel(mistral_config)
+    
+    # Cache it
+    _model_cache[cache_key] = model
+    
+    return model
+
+def get_model_info(model_name: str) -> Optional[Dict[str, Any]]:
+    """
+    Get information about a model
+    
+    Args:
+        model_name: Name of the model
+        
+    Returns:
+        Model information dictionary or None
+    """
+    info = AVAILABLE_MODELS.get(model_name)
+    if info:
+        # Add requirements
+        requirements = MODEL_REQUIREMENTS.get(model_name, {})
+        info["requirements"] = requirements
+        
+        # Add loading status
+        cache_keys = [k for k in _model_cache.keys() if k.startswith(model_name)]
+        info["is_loaded"] = len(cache_keys) > 0
+        
+    return info
+
+def clear_model_cache(model_name: Optional[str] = None):
+    """
+    Clear model cache to free memory
+    
+    Args:
+        model_name: Specific model to clear, or None for all
+    """
+    global _model_cache
+    
+    if model_name:
+        # Clear specific model
+        keys_to_remove = [k for k in _model_cache.keys() if k.startswith(model_name)]
+        for key in keys_to_remove:
+            del _model_cache[key]
+    else:
+        # Clear all
+        _model_cache.clear()
+    
+    # Force garbage collection
+    import gc
+    gc.collect()
+    
+    # Clear GPU cache if using CUDA
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+# Utility functions
+def estimate_memory_usage(model_name: str) -> Dict[str, Any]:
+    """
+    Estimate memory usage for a model
+    
+    Args:
+        model_name: Name of the model
+        
+    Returns:
+        Memory estimation dictionary
+    """
+    model_info = AVAILABLE_MODELS.get(model_name)
+    if not model_info:
+        return {}
+    
+    size = model_info.get("size", "7B")
+    size_gb = float(size.replace("B", ""))
+    
+    estimates = {
+        "model_size_gb": size_gb,
+        "fp32_memory_gb": size_gb * 4,  # 4 bytes per parameter
+        "fp16_memory_gb": size_gb * 2,  # 2 bytes per parameter
+        "int8_memory_gb": size_gb,      # 1 byte per parameter
+        "recommended_ram_gb": size_gb * 2.5,
+        "recommended_vram_gb": size_gb * 1.5
+    }
+    
+    return estimates
+
+def get_device_info() -> Dict[str, Any]:
+    """Get information about available compute devices"""
+    info = {
+        "cuda_available": torch.cuda.is_available(),
+        "device_count": torch.cuda.device_count() if torch.cuda.is_available() else 0,
+        "current_device": torch.cuda.current_device() if torch.cuda.is_available() else None,
+        "device_name": torch.cuda.get_device_name() if torch.cuda.is_available() else "CPU"
+    }
+    
+    if torch.cuda.is_available():
+        info["gpu_memory"] = {
+            "allocated": torch.cuda.memory_allocated() / 1024**3,  # GB
+            "reserved": torch.cuda.memory_reserved() / 1024**3,    # GB
+            "total": torch.cuda.get_device_properties(0).total_memory / 1024**3  # GB
+        }
+    
+    return info
+
+# Module initialization
+import os
+if os.getenv("DEBUG_MODE", "false").lower() == "true":
+    print(f"Models module v{__version__} initialized")
+    device_info = get_device_info()
+    print(f"Device: {device_info['device_name']}")
+    if device_info['cuda_available']:
+        print(f"GPU Memory: {device_info['gpu_memory']['total']:.1f}GB")

models/mistral_model.py

@@ -0,0 +1,105 @@
+"""
+Mistral Model Wrapper for easy integration
+"""
+import os
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+from typing import Optional
+HUGGINGFACE_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
+class MistralModel:
+    """Wrapper for Mistral model with caching and optimization"""
+    
+    _instance = None
+    _model = None
+    _tokenizer = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        if MistralModel._model is None:
+            self._initialize_model()
+    
+    def _initialize_model(self):
+        """Initialize Mistral model with optimizations"""
+        print("Loading Mistral model...")
+        
+        model_id = "mistralai/Mistral-7B-Instruct-v0.2"
+        
+        # Load tokenizer
+        MistralModel._tokenizer = AutoTokenizer.from_pretrained(model_id, token=HUGGINGFACE_TOKEN)
+        
+        # Load model with optimizations
+        MistralModel._model = AutoModelForCausalLM.from_pretrained(
+            model_id,
+            token=HUGGINGFACE_TOKEN,
+            torch_dtype=torch.float16,
+            device_map="auto",
+            load_in_8bit=True  # Use 8-bit quantization for memory efficiency
+        )
+        
+        print("Mistral model loaded successfully!")
+    
+    def generate(
+        self, 
+        prompt: str, 
+        max_length: int = 512,
+        temperature: float = 0.7,
+        top_p: float = 0.95
+    ) -> str:
+        """Generate response from Mistral"""
+        
+        # Format prompt for Mistral instruction format
+        formatted_prompt = f"<s>[INST] {prompt} [/INST]"
+        
+        # Tokenize
+        inputs = MistralModel._tokenizer(
+            formatted_prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=2048
+        )
+        
+        # Move to device
+        device = next(MistralModel._model.parameters()).device
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        # Generate
+        with torch.no_grad():
+            outputs = MistralModel._model.generate(
+                **inputs,
+                max_new_tokens=max_length,
+                temperature=temperature,
+                top_p=top_p,
+                do_sample=True,
+                pad_token_id=MistralModel._tokenizer.eos_token_id
+            )
+        
+        # Decode
+        response = MistralModel._tokenizer.decode(
+            outputs[0][inputs['input_ids'].shape[1]:],
+            skip_special_tokens=True
+        )
+        
+        return response.strip()
+    
+    def generate_embedding(self, text: str) -> torch.Tensor:
+        """Generate embeddings for text"""
+        inputs = MistralModel._tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512
+        )
+        
+        device = next(MistralModel._model.parameters()).device
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        with torch.no_grad():
+            outputs = MistralModel._model(**inputs, output_hidden_states=True)
+            # Use last hidden state as embedding
+            embeddings = outputs.hidden_states[-1].mean(dim=1)
+        
+        return embeddings

requirements.txt

@@ -0,0 +1,63 @@
+crewai
+#langchain==0.1.19
+langchain
+#langchain-community==0.0.38
+langchain-community
+langchain-core
+#pydantic==2.5.0
+pydantic
+# Optional: Gradio and supporting tools
+gradio==4.19.2
+numpy==1.26.4
+faiss-cpu==1.7.4
+sentence-transformers==2.2.2
+transformers==4.36.0
+torch
+accelerate==0.25.0
+huggingface-hub==0.20.2
+openai-whisper==20231117
+#edge-tts==6.1.9
+speechrecognition==3.10.1
+gtts==2.5.0
+pyttsx3==2.90
+python-dotenv==1.0.0
+pandas==2.0.3
+aiofiles==23.2.1
+duckduckgo-search==5.0
+beautifulsoup4==4.12.3
+onnxruntime==1.16.3
+embedchain
+torchaudio
+torchvision
+certifi==2023.07.22
+python-dotenv
+soundfile
+
+# crewai==0.23.1
+# langchain==0.1.19                        # Pinning to known stable
+# langchain-community==0.0.41               # Latest as of June 2024
+# langchain-core==0.1.44                    # Match langchain compatibility
+# pydantic==2.6.4                           # v2.x required by LangChain
+# gradio==4.19.2
+# numpy==1.26.4
+# faiss-cpu==1.7.4
+# sentence-transformers==2.2.2
+# transformers==4.36.2                      # Small bump for bugfixes
+# torch==2.2.2                              # Stable and supported by other libs
+# accelerate==0.25.0
+# huggingface-hub==0.20.2
+# openai-whisper==20231117
+# speechrecognition==3.10.1
+# gtts==2.5.0
+# pyttsx3==2.90
+# python-dotenv==1.0.1                      # Use latest: bugfixes
+# pandas==2.2.2                             # Compatible w/ numpy 1.26.x
+# aiofiles==23.2.1
+# duckduckgo-search==5.1.0                  # Latest, works w/ Python 3.9+
+# beautifulsoup4==4.12.3
+# onnxruntime==1.16.3
+# embedchain==0.0.36                        # Works with Transformers/Torch
+# torchaudio==2.2.2                         # Must match Torch version!
+# torchvision==0.17.2                       # Must match Torch version!
+# certifi==2023.07.22
+# soundfile==0.12.1                         # Explicit version

setup_knowledge.py

@@ -0,0 +1,258 @@
+"""
+Enhanced setup script with more comprehensive knowledge base
+"""
+
+import os
+import sys
+from pathlib import Path
+import numpy as np
+import faiss
+import pickle
+from sentence_transformers import SentenceTransformer
+from typing import List, Dict
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Extended wisdom database with more texts
+WISDOM_DATABASE = [
+    # Bhagavad Gita
+    {
+        "text": "The mind is restless and difficult to restrain, but it is subdued by practice.",
+        "source": "Bhagavad Gita",
+        "chapter": "6.35",
+        "tags": ["mind", "practice", "discipline"]
+    },
+    {
+        "text": "Set thy heart upon thy work, but never on its reward.",
+        "source": "Bhagavad Gita", 
+        "chapter": "2.47",
+        "tags": ["work", "detachment", "karma"]
+    },
+    {
+        "text": "The soul is neither born, and nor does it die.",
+        "source": "Bhagavad Gita",
+        "chapter": "2.20", 
+        "tags": ["soul", "eternal", "death"]
+    },
+    
+    # Autobiography of a Yogi
+    {
+        "text": "The season of failure is the best time for sowing the seeds of success.",
+        "source": "Autobiography of a Yogi",
+        "tags": ["failure", "success", "growth"]
+    },
+    {
+        "text": "Live quietly in the moment and see the beauty of all before you.",
+        "source": "Autobiography of a Yogi",
+        "tags": ["present", "beauty", "mindfulness"]
+    },
+    
+    # The Power of Now
+    {
+        "text": "Realize deeply that the present moment is all you have.",
+        "source": "The Power of Now",
+        "tags": ["present", "awareness", "now"]
+    },
+    {
+        "text": "The primary cause of unhappiness is never the situation but your thoughts about it.",
+        "source": "The Power of Now",
+        "tags": ["unhappiness", "thoughts", "perception"]
+    },
+    {
+        "text": "Life will give you whatever experience is most helpful for the evolution of your consciousness.",
+        "source": "The Power of Now",
+        "tags": ["life", "experience", "consciousness"]
+    },
+    
+    # Man's Search for Meaning
+    {
+        "text": "When we are no longer able to change a situation, we are challenged to change ourselves.",
+        "source": "Man's Search for Meaning",
+        "tags": ["change", "adaptation", "growth"]
+    },
+    {
+        "text": "Those who have a 'why' to live, can bear with almost any 'how'.",
+        "source": "Man's Search for Meaning",
+        "tags": ["purpose", "meaning", "resilience"]
+    },
+    
+    # Atomic Habits
+    {
+        "text": "You do not rise to the level of your goals. You fall to the level of your systems.",
+        "source": "Atomic Habits",
+        "tags": ["goals", "systems", "habits"]
+    },
+    {
+        "text": "Every action you take is a vote for the type of person you wish to become.",
+        "source": "Atomic Habits",
+        "tags": ["identity", "actions", "becoming"]
+    },
+    {
+        "text": "Habits are the compound interest of self-improvement.",
+        "source": "Atomic Habits",
+        "tags": ["habits", "improvement", "compound"]
+    },
+    
+    # Meditations - Marcus Aurelius
+    {
+        "text": "You have power over your mind - not outside events. Realize this, and you will find strength.",
+        "source": "Meditations",
+        "tags": ["control", "mind", "strength"]
+    },
+    {
+        "text": "The best revenge is not to be like your enemy.",
+        "source": "Meditations",
+        "tags": ["revenge", "character", "virtue"]
+    },
+    {
+        "text": "What we cannot bear removes us from life; what remains can be borne.",
+        "source": "Meditations",
+        "tags": ["endurance", "life", "strength"]
+    },
+    
+    # Tao Te Ching
+    {
+        "text": "When I let go of what I am, I become what I might be.",
+        "source": "Tao Te Ching",
+        "tags": ["letting go", "becoming", "potential"]
+    },
+    {
+        "text": "The journey of a thousand miles begins with a single step.",
+        "source": "Tao Te Ching",
+        "tags": ["journey", "beginning", "action"]
+    },
+    {
+        "text": "Knowing others is intelligence; knowing yourself is true wisdom.",
+        "source": "Tao Te Ching",
+        "tags": ["self-knowledge", "wisdom", "intelligence"]
+    },
+    
+    # 7 Habits of Highly Effective People
+    {
+        "text": "Between stimulus and response there is a space. In that space is our power to choose our response.",
+        "source": "7 Habits of Highly Effective People",
+        "tags": ["choice", "response", "freedom"]
+    },
+    {
+        "text": "Begin with the end in mind.",
+        "source": "7 Habits of Highly Effective People",
+        "tags": ["vision", "planning", "purpose"]
+    },
+    
+    # Mindset
+    {
+        "text": "Becoming is better than being.",
+        "source": "Mindset",
+        "tags": ["growth", "becoming", "fixed mindset"]
+    },
+    {
+        "text": "The view you adopt for yourself profoundly affects the way you lead your life.",
+        "source": "Mindset",
+        "tags": ["perspective", "self-view", "life"]
+    },
+    
+    # Additional Universal Wisdom
+    {
+        "text": "The wound is the place where the Light enters you.",
+        "source": "Rumi",
+        "tags": ["pain", "growth", "transformation"]
+    },
+    {
+        "text": "Yesterday I was clever, so I wanted to change the world. Today I am wise, so I am changing myself.",
+        "source": "Rumi",
+        "tags": ["change", "wisdom", "self"]
+    },
+    {
+        "text": "Do not dwell in the past, do not dream of the future, concentrate the mind on the present moment.",
+        "source": "Buddha",
+        "tags": ["present", "past", "future"]
+    }
+]
+
+def setup_comprehensive_knowledge_base():
+    """Setup knowledge base with all wisdom texts"""
+    print("Setting up comprehensive knowledge base...")
+    
+    # Create directories
+    data_dir = Path("data")
+    faiss_dir = data_dir / "faiss_index"
+    books_dir = data_dir / "books"
+    
+    for dir_path in [data_dir, faiss_dir, books_dir]:
+        dir_path.mkdir(exist_ok=True)
+    
+    # Initialize embedder
+    print("Loading sentence transformer model...")
+    embedder = SentenceTransformer('all-MiniLM-L6-v2')
+    
+    # Process wisdom texts
+    texts = []
+    metadata = []
+    
+    for item in WISDOM_DATABASE:
+        texts.append(item["text"])
+        metadata.append({
+            "source": item["source"],
+            "chapter": item.get("chapter", ""),
+            "tags": item.get("tags", [])
+        })
+    
+    # Create embeddings
+    print(f"Creating embeddings for {len(texts)} wisdom passages...")
+    embeddings = embedder.encode(texts, show_progress_bar=True)
+    
+    # Create FAISS index with cosine similarity
+    dimension = embeddings.shape[1]
+    
+    # Normalize embeddings for cosine similarity
+    faiss.normalize_L2(embeddings)
+    
+    # Use Inner Product (equivalent to cosine similarity after normalization)
+    index = faiss.IndexFlatIP(dimension)
+    index.add(embeddings.astype('float32'))
+    
+    # Save everything
+    print("Saving knowledge base...")
+    faiss.write_index(index, str(faiss_dir / "index.faiss"))
+    
+    with open(faiss_dir / "passages.pkl", 'wb') as f:
+        pickle.dump(texts, f)
+    
+    with open(faiss_dir / "metadata.pkl", 'wb') as f:
+        pickle.dump(metadata, f)
+    
+    print(f"✅ Knowledge base setup complete!")
+    print(f"   - Total passages: {len(texts)}")
+    print(f"   - Embedding dimension: {dimension}")
+    print(f"   - Index type: Cosine similarity (normalized L2)")
+    
+    # Create placeholder book files
+    print("\nCreating placeholder book files...")
+    book_files = [
+        "bhagavad_gita.txt",
+        "autobiography_of_a_yogi.txt",
+        "the_power_of_now.txt",
+        "mans_search_for_meaning.txt",
+        "atomic_habits.txt",
+        "meditations.txt",
+        "tao_te_ching.txt",
+        "dhyana_vahini.txt",
+        "7_habits.txt",
+        "mindset.txt",
+        "prema_vahini.txt",
+        "prasnothara_vahini.txt"
+    ]
+    
+    for book_file in book_files:
+        filepath = books_dir / book_file
+        if not filepath.exists():
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(f"Placeholder for {book_file}\nAdd full text here.")
+    
+    print("✅ Setup complete! You can now run the main application.")
+    print("\nTo add full books:")
+    print("1. Replace placeholder files in data/books/ with full text")
+    print("2. Re-run this script to update the knowledge base")
+
+if __name__ == "__main__":
+    setup_comprehensive_knowledge_base()

utils/_init_.py

@@ -0,0 +1,8 @@
+"""
+Utility modules for Personal Coach CrewAI Application
+"""
+
+from .config import Config
+from .knowledge_base import KnowledgeBase
+
+__all__ = ['Config', 'KnowledgeBase']

utils/config.py

@@ -0,0 +1,298 @@
+"""
+Configuration management for Personal Coach CrewAI
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+from dotenv import load_dotenv
+import torch
+
+# Load environment variables
+load_dotenv()
+
+@dataclass
+class ModelConfig:
+    """Model configuration settings"""
+    # Mistral model for main LLM
+    mistral_model: str = "mistralai/Mistral-7B-Instruct-v0.1"
+    
+    # Embedding model for RAG
+    embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2"
+    
+    # Whisper model for multilingual STT
+    whisper_model: str = "openai/whisper-small"
+    
+    # TTS models for different languages
+    tts_models: Dict[str, str] = None
+    
+    # Model parameters
+    max_length: int = 2048
+    temperature: float = 0.7
+    top_p: float = 0.95
+    do_sample: bool = True
+    
+    # Device configuration
+    device: str = "cuda" if torch.cuda.is_available() else "cpu"
+    torch_dtype: torch.dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+    
+    def __post_init__(self):
+        if self.tts_models is None:
+            self.tts_models = {
+                "en": "microsoft/speecht5_tts",
+                "hi": "facebook/mms-tts-hin",
+                "es": "facebook/mms-tts-spa",
+                "fr": "facebook/mms-tts-fra",
+                "de": "facebook/mms-tts-deu",
+                "zh": "facebook/mms-tts-cmn",
+                "ar": "facebook/mms-tts-ara",
+                "default": "microsoft/speecht5_tts"
+            }
+
+@dataclass
+class VectorStoreConfig:
+    """Vector store configuration for knowledge base"""
+    index_type: str = "Flat"  # FAISS index type
+    dimension: int = 384  # for all-MiniLM-L6-v2
+    metric: str = "cosine"  # similarity metric
+    n_results: int = 5  # number of results to retrieve
+    chunk_size: int = 500  # text chunk size
+    chunk_overlap: int = 50  # overlap between chunks
+    
+@dataclass
+class AudioConfig:
+    """Audio processing configuration"""
+    sample_rate: int = 16000
+    chunk_length: int = 30  # seconds
+    language_detection: bool = True
+    supported_languages: List[str] = None
+    
+    def __post_init__(self):
+        if self.supported_languages is None:
+            self.supported_languages = [
+                "en", "es", "fr", "de", "it", "pt", "ru", "zh", 
+                "ja", "ko", "hi", "ar", "bn", "pa", "te", "mr", 
+                "ta", "ur", "gu", "kn", "ml", "or"
+            ]
+
+@dataclass
+class CrewConfig:
+    """CrewAI specific configuration"""
+    max_iterations: int = 3
+    memory: bool = True
+    verbose: bool = True
+    temperature: float = 0.7
+    max_rpm: int = 10  # rate limiting
+    
+    # Agent-specific settings
+    agent_settings: Dict[str, Dict] = None
+    
+    def __post_init__(self):
+        if self.agent_settings is None:
+            self.agent_settings = {
+                "conversation_handler": {
+                    "max_questions": 3,
+                    "empathy_level": "high",
+                    "response_style": "warm"
+                },
+                "knowledge_advisor": {
+                    "search_depth": 5,
+                    "context_window": 3,
+                    "wisdom_sources": ["all"]
+                },
+                "response_validator": {
+                    "safety_threshold": 0.9,
+                    "tone_check": True,
+                    "fact_check": False
+                },
+                "interaction_manager": {
+                    "voice_speed": 1.0,
+                    "voice_pitch": 1.0,
+                    "include_followup": True
+                }
+            }
+
+class Config:
+    """Main configuration class"""
+    
+    def __init__(self):
+        # Base paths
+        self.BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        self.DATA_DIR = os.path.join(self.BASE_DIR, "data")
+        self.BOOKS_DIR = os.path.join(self.DATA_DIR, "books")
+        self.INDEX_DIR = os.path.join(self.DATA_DIR, "faiss_index")
+        self.CACHE_DIR = os.path.join(self.BASE_DIR, ".cache")
+        self.LOGS_DIR = os.path.join(self.BASE_DIR, "logs")
+        
+        # Create necessary directories
+        for directory in [self.DATA_DIR, self.BOOKS_DIR, self.INDEX_DIR, self.CACHE_DIR, self.LOGS_DIR]:
+            os.makedirs(directory, exist_ok=True)
+        
+        # Model configuration
+        self.models = ModelConfig(
+            mistral_model=os.getenv("MISTRAL_MODEL", ModelConfig.mistral_model),
+            embedding_model=os.getenv("EMBEDDING_MODEL", ModelConfig.embedding_model),
+            whisper_model=os.getenv("WHISPER_MODEL", ModelConfig.whisper_model),
+            temperature=float(os.getenv("TEMPERATURE", "0.7")),
+            max_length=int(os.getenv("MAX_LENGTH", "2048"))
+        )
+        
+        # Vector store configuration
+        self.vector_store = VectorStoreConfig(
+            chunk_size=int(os.getenv("CHUNK_SIZE", "500")),
+            n_results=int(os.getenv("N_RESULTS", "5"))
+        )
+        
+        # Audio configuration
+        self.audio = AudioConfig(
+            sample_rate=int(os.getenv("SAMPLE_RATE", "16000")),
+            language_detection=os.getenv("LANGUAGE_DETECTION", "true").lower() == "true"
+        )
+        
+        # CrewAI configuration
+        self.crew = CrewConfig(
+            verbose=os.getenv("CREW_VERBOSE", "true").lower() == "true",
+            max_iterations=int(os.getenv("MAX_ITERATIONS", "3"))
+        )
+        
+        # API tokens
+        self.tokens = {
+            "huggingface": os.getenv("HUGGINGFACE_TOKEN", ""),
+            "openai": os.getenv("OPENAI_API_KEY", "")
+        }
+        
+        # Feature flags
+        self.features = {
+            "voice_enabled": os.getenv("VOICE_ENABLED", "true").lower() == "true",
+            "multilingual": os.getenv("MULTILINGUAL", "true").lower() == "true",
+            "save_history": os.getenv("SAVE_HISTORY", "true").lower() == "true",
+            "debug_mode": os.getenv("DEBUG_MODE", "false").lower() == "true"
+        }
+        
+        # Knowledge base books
+        self.knowledge_sources = {
+            "spiritual": [
+                "Bhagavad Gita",
+                "Autobiography of a Yogi",
+                "The Power of Now",
+                "Tao Te Ching",
+                "Dhyana Vahini",
+                "Gita Vahini",
+                "Prema Vahini",
+                "Prasnothra Vahini"
+            ],
+            "self_help": [
+                "Atomic Habits",
+                "The 7 Habits of Highly Effective People",
+                "Man's Search for Meaning",
+                "Mindset"
+            ],
+            "philosophy": [
+                "Meditations"
+            ]
+        }
+        
+        # Prompt templates
+        self.prompts = {
+            "system_prompt": """You are a compassionate personal coach who draws wisdom from ancient texts and modern psychology. 
+            You listen deeply, ask thoughtful questions, and provide guidance that is both practical and profound. 
+            You speak with warmth and understanding, never judging, always supporting.""",
+            
+            "conversation_prompt": """Based on what the user shared: {user_input}
+            Their emotional state appears to be: {emotional_state}
+            Generate {num_questions} empathetic, reflective questions to help them explore their feelings deeper.""",
+            
+            "wisdom_prompt": """The user is dealing with: {situation}
+            Their emotional state: {emotional_state}
+            
+            Drawing from these wisdom sources: {sources}
+            Provide relevant guidance that:
+            1. Acknowledges their feelings
+            2. Shares applicable wisdom
+            3. Offers practical steps
+            4. Maintains a supportive tone""",
+            
+            "validation_prompt": """Review this response for appropriateness:
+            {response}
+            
+            Ensure it:
+            1. Contains no medical/legal/financial advice
+            2. Maintains supportive tone
+            3. Includes practical guidance
+            4. Avoids absolute statements""",
+            
+            "meditation_prompt": """Create a {duration} minute meditation practice for someone feeling {emotion}.
+            Include:
+            1. Simple setup instructions
+            2. Step-by-step guidance
+            3. Focus technique
+            4. Closing reflection"""
+        }
+        
+        # Response guidelines
+        self.guidelines = {
+            "tone": ["empathetic", "supportive", "non-judgmental", "encouraging"],
+            "avoid": ["prescriptive", "absolute", "diagnostic", "dismissive"],
+            "include": ["validation", "practical steps", "hope", "empowerment"]
+        }
+        
+        # Crisis resources
+        self.crisis_resources = {
+            "global": {
+                "name": "International Crisis Lines",
+                "url": "https://findahelpline.com",
+                "phone": "Various by country"
+            },
+            "us": {
+                "name": "988 Suicide & Crisis Lifeline",
+                "phone": "988",
+                "text": "Text HOME to 741741"
+            },
+            "uk": {
+                "name": "Samaritans",
+                "phone": "116 123",
+                "email": "jo@samaritans.org"
+            },
+            "india": {
+                "name": "Vandrevala Foundation",
+                "phone": "9999666555",
+                "languages": ["Hindi", "English", "Regional"]
+            }
+        }
+    
+    def get_language_config(self, language_code: str) -> Dict:
+        """Get language-specific configuration"""
+        language_configs = {
+            "en": {"name": "English", "tts_voice": "en-US-AriaNeural"},
+            "hi": {"name": "Hindi", "tts_voice": "hi-IN-SwaraNeural"},
+            "es": {"name": "Spanish", "tts_voice": "es-ES-ElviraNeural"},
+            "fr": {"name": "French", "tts_voice": "fr-FR-DeniseNeural"},
+            "de": {"name": "German", "tts_voice": "de-DE-KatjaNeural"},
+            "zh": {"name": "Chinese", "tts_voice": "zh-CN-XiaoxiaoNeural"},
+            "ar": {"name": "Arabic", "tts_voice": "ar-SA-ZariyahNeural"}
+        }
+        
+        return language_configs.get(language_code, language_configs["en"])
+    
+    def get_prompt(self, prompt_type: str, **kwargs) -> str:
+        """Get formatted prompt with variables"""
+        prompt_template = self.prompts.get(prompt_type, "")
+        return prompt_template.format(**kwargs)
+    
+    def to_dict(self) -> Dict:
+        """Convert configuration to dictionary"""
+        return {
+            "paths": {
+                "base": self.BASE_DIR,
+                "data": self.DATA_DIR,
+                "books": self.BOOKS_DIR,
+                "index": self.INDEX_DIR,
+                "cache": self.CACHE_DIR
+            },
+            "models": self.models.__dict__,
+            "vector_store": self.vector_store.__dict__,
+            "audio": self.audio.__dict__,
+            "crew": self.crew.__dict__,
+            "features": self.features,
+            "knowledge_sources": self.knowledge_sources
+        }

utils/knowledge_base.py

@@ -0,0 +1,339 @@
+"""
+Knowledge base management using FAISS and HuggingFace embeddings
+"""
+
+import os
+import json
+import pickle
+from typing import List, Dict, Tuple, Optional
+import numpy as np
+import faiss
+from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer
+import hashlib
+from datetime import datetime
+from pathlib import Path
+
+class KnowledgeBase:
+    """Manages the vector store for knowledge retrieval"""
+    
+    def __init__(self, config):
+        self.config = config
+        self.embedding_model = SentenceTransformer(config.models.embedding_model)
+        self.dimension = config.vector_store.dimension
+        self.index = None
+        self.metadata = []
+        self.chunks = []
+        self.index_path = config.INDEX_DIR
+        self.books_path = config.BOOKS_DIR
+        
+        # Initialize tokenizer for chunk splitting
+        self.tokenizer = AutoTokenizer.from_pretrained(config.models.mistral_model)
+        
+        # Load or create index
+        self._initialize_index()
+    
+    def _initialize_index(self):
+        """Initialize or load existing FAISS index"""
+        index_file = os.path.join(self.index_path, "knowledge.index")
+        metadata_file = os.path.join(self.index_path, "metadata.pkl")
+        chunks_file = os.path.join(self.index_path, "chunks.pkl")
+        
+        if os.path.exists(index_file) and os.path.exists(metadata_file):
+            # Load existing index
+            self.index = faiss.read_index(index_file)
+            with open(metadata_file, 'rb') as f:
+                self.metadata = pickle.load(f)
+            with open(chunks_file, 'rb') as f:
+                self.chunks = pickle.load(f)
+            print(f"Loaded existing index with {self.index.ntotal} vectors")
+        else:
+            # Create new index
+            if self.config.vector_store.metric == "cosine":
+                # Use IndexFlatIP with normalized vectors for cosine similarity
+                self.index = faiss.IndexFlatIP(self.dimension)
+            else:
+                # Use IndexFlatL2 for Euclidean distance
+                self.index = faiss.IndexFlatL2(self.dimension)
+            print("Created new index")
+    
+    def process_books(self, force_rebuild: bool = False):
+        """Process all books in the books directory"""
+        if self.index.ntotal > 0 and not force_rebuild:
+            print(f"Index already contains {self.index.ntotal} vectors. Use force_rebuild=True to rebuild.")
+            return
+        
+        # Clear existing data if rebuilding
+        if force_rebuild:
+            self.index = faiss.IndexFlatIP(self.dimension) if self.config.vector_store.metric == "cosine" else faiss.IndexFlatL2(self.dimension)
+            self.metadata = []
+            self.chunks = []
+        
+        # Process each book
+        book_files = list(Path(self.books_path).glob("*.txt"))
+        print(f"Found {len(book_files)} books to process")
+        
+        for book_file in book_files:
+            print(f"Processing {book_file.name}...")
+            self._process_single_book(book_file)
+        
+        # Save index
+        self._save_index()
+        print(f"Processing complete. Index contains {self.index.ntotal} vectors")
+    
+    def _process_single_book(self, book_path: Path):
+        """Process a single book file"""
+        try:
+            # Read book content
+            with open(book_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            # Extract book name
+            book_name = book_path.stem.replace('_', ' ').title()
+            
+            # Split into chunks
+            chunks = self._create_chunks(content)
+            
+            # Process each chunk
+            for i, chunk in enumerate(chunks):
+                # Skip empty chunks
+                if not chunk.strip():
+                    continue
+                
+                # Create embedding
+                embedding = self._create_embedding(chunk)
+                
+                # Normalize for cosine similarity
+                if self.config.vector_store.metric == "cosine":
+                    embedding = embedding / np.linalg.norm(embedding)
+                
+                # Add to index
+                self.index.add(np.array([embedding]))
+                
+                # Store metadata
+                metadata = {
+                    "book": book_name,
+                    "chunk_id": i,
+                    "timestamp": datetime.now().isoformat(),
+                    "char_count": len(chunk),
+                    "checksum": hashlib.md5(chunk.encode()).hexdigest()
+                }
+                self.metadata.append(metadata)
+                self.chunks.append(chunk)
+                
+        except Exception as e:
+            print(f"Error processing {book_path}: {str(e)}")
+    
+    def _create_chunks(self, text: str) -> List[str]:
+        """Split text into chunks using sliding window"""
+        # Clean text
+        text = text.strip()
+        if not text:
+            return []
+        
+        # Tokenize
+        tokens = self.tokenizer.encode(text, add_special_tokens=False)
+        
+        chunks = []
+        chunk_size = self.config.vector_store.chunk_size
+        overlap = self.config.vector_store.chunk_overlap
+        
+        # Create chunks with overlap
+        for i in range(0, len(tokens), chunk_size - overlap):
+            chunk_tokens = tokens[i:i + chunk_size]
+            chunk_text = self.tokenizer.decode(chunk_tokens, skip_special_tokens=True)
+            chunks.append(chunk_text)
+        
+        return chunks
+    
+    def _create_embedding(self, text: str) -> np.ndarray:
+        """Create embedding for text"""
+        embedding = self.embedding_model.encode(text, convert_to_numpy=True)
+        return embedding.astype('float32')
+    
+    def search(self, query: str, k: int = None, filter_books: List[str] = None) -> List[Dict]:
+        """Search for similar chunks in the knowledge base"""
+        if self.index.ntotal == 0:
+            return []
+        
+        k = k or self.config.vector_store.n_results
+        
+        # Create query embedding
+        query_embedding = self._create_embedding(query)
+        
+        # Normalize for cosine similarity
+        if self.config.vector_store.metric == "cosine":
+            query_embedding = query_embedding / np.linalg.norm(query_embedding)
+        
+        # Search
+        distances, indices = self.index.search(
+            np.array([query_embedding]), 
+            min(k, self.index.ntotal)
+        )
+        
+        # Compile results
+        results = []
+        for i, (dist, idx) in enumerate(zip(distances[0], indices[0])):
+            if idx < 0:  # Invalid index
+                continue
+                
+            metadata = self.metadata[idx]
+            
+            # Apply book filter if specified
+            if filter_books and metadata["book"] not in filter_books:
+                continue
+            
+            result = {
+                "text": self.chunks[idx],
+                "book": metadata["book"],
+                "score": float(dist),
+                "rank": i + 1,
+                "metadata": metadata
+            }
+            results.append(result)
+        
+        # Sort by score (higher is better for cosine similarity)
+        results.sort(key=lambda x: x["score"], reverse=True)
+        
+        return results[:k]
+    
+    def search_with_context(self, query: str, k: int = None, context_window: int = 1) -> List[Dict]:
+        """Search and include surrounding context chunks"""
+        results = self.search(query, k)
+        
+        # Expand each result with context
+        expanded_results = []
+        for result in results:
+            chunk_idx = result["metadata"]["chunk_id"]
+            book = result["book"]
+            
+            # Get surrounding chunks from the same book
+            context_chunks = []
+            
+            # Get previous chunks
+            for i in range(context_window, 0, -1):
+                prev_idx = self._find_chunk_index(book, chunk_idx - i)
+                if prev_idx is not None:
+                    context_chunks.append(self.chunks[prev_idx])
+            
+            # Add main chunk
+            context_chunks.append(result["text"])
+            
+            # Get next chunks
+            for i in range(1, context_window + 1):
+                next_idx = self._find_chunk_index(book, chunk_idx + i)
+                if next_idx is not None:
+                    context_chunks.append(self.chunks[next_idx])
+            
+            # Create expanded result
+            expanded_result = result.copy()
+            expanded_result["context"] = "\n\n".join(context_chunks)
+            expanded_result["context_size"] = len(context_chunks)
+            expanded_results.append(expanded_result)
+        
+        return expanded_results
+    
+    def _find_chunk_index(self, book: str, chunk_id: int) -> Optional[int]:
+        """Find index of a specific chunk"""
+        for i, metadata in enumerate(self.metadata):
+            if metadata["book"] == book and metadata["chunk_id"] == chunk_id:
+                return i
+        return None
+    
+    def add_text(self, text: str, source: str, metadata: Dict = None):
+        """Add a single text to the knowledge base"""
+        # Create chunks
+        chunks = self._create_chunks(text)
+        
+        # Process each chunk
+        for i, chunk in enumerate(chunks):
+            if not chunk.strip():
+                continue
+            
+            # Create embedding
+            embedding = self._create_embedding(chunk)
+            
+            # Normalize if needed
+            if self.config.vector_store.metric == "cosine":
+                embedding = embedding / np.linalg.norm(embedding)
+            
+            # Add to index
+            self.index.add(np.array([embedding]))
+            
+            # Create metadata
+            chunk_metadata = {
+                "book": source,
+                "chunk_id": i,
+                "timestamp": datetime.now().isoformat(),
+                "char_count": len(chunk),
+                "checksum": hashlib.md5(chunk.encode()).hexdigest()
+            }
+            
+            # Add custom metadata if provided
+            if metadata:
+                chunk_metadata.update(metadata)
+            
+            self.metadata.append(chunk_metadata)
+            self.chunks.append(chunk)
+        
+        # Save changes
+        self._save_index()
+    
+    def _save_index(self):
+        """Save index and metadata to disk"""
+        os.makedirs(self.index_path, exist_ok=True)
+        
+        # Save FAISS index
+        index_file = os.path.join(self.index_path, "knowledge.index")
+        faiss.write_index(self.index, index_file)
+        
+        # Save metadata
+        metadata_file = os.path.join(self.index_path, "metadata.pkl")
+        with open(metadata_file, 'wb') as f:
+            pickle.dump(self.metadata, f)
+        
+        # Save chunks
+        chunks_file = os.path.join(self.index_path, "chunks.pkl")
+        with open(chunks_file, 'wb') as f:
+            pickle.dump(self.chunks, f)
+        
+        # Save config
+        config_file = os.path.join(self.index_path, "config.json")
+        with open(config_file, 'w') as f:
+            json.dump({
+                "dimension": self.dimension,
+                "metric": self.config.vector_store.metric,
+                "total_chunks": len(self.chunks),
+                "books": list(set(m["book"] for m in self.metadata)),
+                "last_updated": datetime.now().isoformat()
+            }, f, indent=2)
+    
+    def get_stats(self) -> Dict:
+        """Get statistics about the knowledge base"""
+        if not self.metadata:
+            return {"status": "empty"}
+        
+        books = {}
+        for metadata in self.metadata:
+            book = metadata["book"]
+            if book not in books:
+                books[book] = {"chunks": 0, "chars": 0}
+            books[book]["chunks"] += 1
+            books[book]["chars"] += metadata["char_count"]
+        
+        return {
+            "total_chunks": len(self.chunks),
+            "total_books": len(books),
+            "books": books,
+            "index_size": self.index.ntotal,
+            "dimension": self.dimension,
+            "metric": self.config.vector_store.metric
+        }
+    
+    def clear(self):
+        """Clear the entire knowledge base"""
+        self.index = faiss.IndexFlatIP(self.dimension) if self.config.vector_store.metric == "cosine" else faiss.IndexFlatL2(self.dimension)
+        self.metadata = []
+        self.chunks = []
+        self._save_index()
+        print("Knowledge base cleared")