Using a current method

.gitignore

@@ -0,0 +1,142 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+logs/
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# Ignore VSCode settings
+.vscode/
+
+# Ignore dataset folder
+/data/
+/vector_embedding/
+*.rdb
+
+# Ignore venv
+thery/

README.md

@@ -10,3 +10,4 @@ short_description: Virtual AI Mental Health Therapist
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+

notebooks/chroma_db_test.ipynb

@@ -0,0 +1,261 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.vectorstores import Chroma \n",
+    "from langchain_openai import OpenAIEmbeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.documents import Document\n",
+    "\n",
+    "documents = [\n",
+    "    Document(\n",
+    "        page_content=\"Dogs are great companions, known for their loyalty and friendliness.\",\n",
+    "        metadata={\"source\": \"mammal-pets-doc\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Cats are independent pets that often enjoy their own space.\",\n",
+    "        metadata={\"source\": \"mammal-pets-doc\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Goldfish are popular pets for beginners, requiring relatively simple care.\",\n",
+    "        metadata={\"source\": \"fish-pets-doc\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Parrots are intelligent birds capable of mimicking human speech.\",\n",
+    "        metadata={\"source\": \"bird-pets-doc\"},\n",
+    "    ),\n",
+    "    Document(\n",
+    "        page_content=\"Rabbits are social animals that need plenty of space to hop around.\",\n",
+    "        metadata={\"source\": \"mammal-pets-doc\"},\n",
+    "    ),\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "db_name = \"test.db\"\n",
+    "persist_directory = os.path.join(\"../vector_embedding\", db_name)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vector_store = Chroma.from_documents(\n",
+    "    documents,\n",
+    "    embedding=OpenAIEmbeddings(),\n",
+    "    persist_directory= persist_directory\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['1a334a0b-6669-4f14-a970-5a53434dbcdb',\n",
+       " '8e2c9a27-80b3-45ef-bee0-637defe360e6',\n",
+       " '884f0d44-8fb6-45e6-9b6c-256dbb5b8620',\n",
+       " '3cc66429-a94c-41bc-a9b0-e2f5f4a7bfbb',\n",
+       " '3c6af7ac-9070-466a-a35d-a6c151080667']"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vector_store.add_documents(documents)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_28475/485603143.py:1: LangChainDeprecationWarning: Since Chroma 0.4.x the manual persistence method is no longer supported as docs are automatically persisted.\n",
+      "  vector_store.persist()\n"
+     ]
+    }
+   ],
+   "source": [
+    "vector_store.persist()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.documents import Document\n",
+    "from langchain_core.prompts import  ChatPromptTemplate\n",
+    "from langchain_core.runnables import RunnablePassthrough"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "retriever = vector_store.as_retriever(\n",
+    "    search_type = \"similarity\",\n",
+    "     search_kwargs={\n",
+    "         'k': 2,\n",
+    "         }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[Document(metadata={'source': 'mammal-pets-doc'}, page_content='Cats are independent pets that often enjoy their own space.'),\n",
+       "  Document(metadata={'source': 'mammal-pets-doc'}, page_content='Dogs are great companions, known for their loyalty and friendliness.')],\n",
+       " [Document(metadata={'source': 'mammal-pets-doc'}, page_content='Dogs are great companions, known for their loyalty and friendliness.'),\n",
+       "  Document(metadata={'source': 'fish-pets-doc'}, page_content='Goldfish are popular pets for beginners, requiring relatively simple care.')]]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "retriever.batch([\"cats\", \"food\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "message =\"\"\"\n",
+    "\n",
+    "Write more on the type of animals based on this context only.\n",
+    "\n",
+    "{question}\n",
+    "\n",
+    "Context:\n",
+    "{context}\n",
+    "\"\"\"\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_messages([(\"human\", message)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI(model=\"gpt-4o-mini\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rag_chain = {\"context\": retriever,\"question\": RunnablePassthrough()} | prompt | model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Based on the provided context, cats can be characterized as independent animals that typically prefer to have their own space. This independence sets them apart from other pets, such as dogs, which are known for their companionship and loyalty. \n",
+      "\n",
+      "Cats are often solitary hunters by nature, which contributes to their self-sufficient demeanor. They can entertain themselves for extended periods and may not require constant interaction or attention from their owners. This trait makes them suitable for individuals or families with busy lifestyles who may not be able to dedicate as much time to a pet.\n",
+      "\n",
+      "Additionally, cats are known for their grooming habits and often spend a significant amount of time cleaning themselves. They are also playful animals, enjoying toys and engaging in activities that mimic hunting behavior, such as pouncing and chasing.\n",
+      "\n",
+      "In terms of personality, cats can vary greatly. Some may be more social and enjoy interacting with humans, while others may be more reserved and prefer to observe from a distance. Their unique personalities can provide a rich and rewarding experience for pet owners who appreciate their distinctive traits.\n",
+      "\n",
+      "Overall, cats represent a diverse group of animals that thrive on independence while still providing companionship in a more subtle and often more relaxed manner compared to other pets.\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = rag_chain.invoke(\"tell me about cats\")\n",
+    "\n",
+    "print(response.content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

pyproject.toml

@@ -0,0 +1,23 @@
+[tool.poetry]
+name = "thetherapist"
+version = "0.1.0"
+description = "Using RAG technique to build an LLM model to serve as a therapist for mentally challenged people"
+authors = ["Testimony Adekoya <[email protected]>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+openai = "^1.40.1"
+langchain-community = "^0.2.11"
+langchain = "^0.2.12"
+langchain-openai = "^0.1.20"
+langchain-core = "^0.2.29"
+chromadb = "^0.5.5"
+fastapi = "^0.112.0"
+gpt-researcher = "^0.8.4"
+md2pdf = "^1.0.1"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,27 @@
+langchain
+langchain-core
+langchain-community
+langchain-text-splitters
+langchain-openai
+langchain-anthropic
+langchain-google-community
+langchain_chroma
+langchain_huggingface
+langchain_google_genai
+fastapi
+gpt-researcher
+chromadb
+md2pdf
+openai
+faiss-cpu
+torch
+transformers
+sentence-transformers
+numpy
+pandas
+langserve
+langsmith
+pydantic
+spotipy
+tavily-python
+python-telegram-bot

src/api.py

@@ -0,0 +1,88 @@
+from fastapi import FastAPI, APIRouter, Depends, HTTPException, Request, Response
+from fastapi.responses import JSONResponse
+import schedule
+import time
+import requests
+import threading
+import asyncio
+import uvicorn
+from multiprocessing import Process
+
+from src.llm.routes import router as conversation_router
+from src.tele_bot.bot import main as run_telegram_bot
+from src.llm.core.config import settings
+from src.llm.agents.conversation_agent import ConversationAgent
+
+def on_startup():
+    global conversation_agent
+    conversation_agent = ConversationAgent()
+
+    
+app = FastAPI(
+    title="TheryAI API",
+    description="API for TheryAI",
+    version="0.1.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json",
+    debug=True,
+    on_startup=[on_startup]
+)
+
+
+
+app.include_router(conversation_router)
+
+@app.get("/")
+async def home():
+    return {"message": "Welcome to TheryAI API"}
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+def ping_server():
+    try:
+        print("Pinging server")
+        response = requests.get("https://theryai-api./")
+    except requests.exceptions.RequestException as e:
+        print("Server is down")
+        # send email to admin
+    
+schedule.every(10).minutes.do(ping_server)
+
+
+def run_schedule():
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
+
+
+thread = threading.Thread(target=run_schedule)
+thread.daemon = True
+thread.start()
+
+
+def run_bot():
+    uvicorn.run(
+        "src.api:app",
+        host="0.0.0.0",
+        port=8000,
+        log_level="info",
+        reload=True,
+    )
+
+def run_telegram_bot():
+    asyncio(run_telegram_bot())
+
+
+if __name__ == "__main__":
+    fastapi_process = Process(target=run_bot)
+    telegram_process = Process(target=run_telegram_bot)
+    
+    fastapi_process.start()
+    telegram_process.start()
+
+    fastapi_process.join()
+    telegram_process.join()
+    

src/llm/agents/base_agent.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import Any, Dict, Optional
+import logging
+from src.llm.core.llm import TheryLLM
+from src.llm.utils.logging import TheryBotLogger
+from src.llm.memory.history import RedisHistory
+from src.llm.memory.session_manager import SessionManager
+
+class BaseAgent(ABC):
+    def __init__(
+        self,
+        llm: Optional[TheryLLM] = None,
+        history: Optional[RedisHistory] = None,
+        session_manager: Optional[SessionManager] = None
+    ):
+        self.llm = llm or TheryLLM()
+        self.logger = TheryBotLogger()
+        self.history = history or RedisHistory()
+        self.memory_manager = session_manager or SessionManager()
+    
+    @abstractmethod
+    def process(self, *args, **kwargs) -> Any:
+        """Process the input and return response"""
+        pass
+        
+    
+    def _log_action(
+        self,
+        action: str,
+        metadata: Dict[str, Any],
+        level: str = logging.INFO,
+        session_id: Optional[str] = None,
+        user_id: Optional[str] = None
+    ) -> None:
+        """
+        Log agent actions with metadata and optional session/user context.
+        
+        Args:
+            action: The action being logged (e.g., "llm_generation_attempt").
+            metadata: A dictionary of metadata related to the action.
+            level: The log level ("info", "warning", "error", etc.).
+            session_id: Optional session ID for context.
+            user_id: Optional user ID for context.
+        """
+        # Prepare log data
+        log_data = {
+            "action": action,
+            "metadata": metadata,
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+
+        # Add session and user context if provided
+        if session_id:
+            log_data["session_id"] = session_id
+        if user_id:
+            log_data["user_id"] = user_id
+
+        # Log the data using the existing logger
+        if hasattr(self, "logger"):
+            self.logger.log_interaction(
+                interaction_type="agent_action",
+                data=log_data,
+                level=level
+            )
+        else:
+            print(f"Logging failed: {log_data}")

src/llm/agents/context_agent.py

@@ -0,0 +1,63 @@
+import os
+import asyncio
+import logging
+from typing import Dict, Any
+from .base_agent import BaseAgent
+from src.llm.core.config import settings
+from src.llm.memory.vector_store import FAISSVectorSearch
+from src.llm.models.schemas import ContextInfo
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.utilities.tavily_search import TavilySearchAPIWrapper
+
+class ContextAgent(BaseAgent):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._initialize_tools()
+
+    def _initialize_tools(self) -> None:
+        """Lazy-load expensive resources"""
+        self.web_search = TavilySearchResults(
+            max_results=settings.TAVILY_MAX_RESULTS,
+            include_answer=settings.TAVILY_INCLUDE_ANSWER,
+            include_images=settings.TAVILY_INCLUDE_IMAGES,
+            api_wrapper=TavilySearchAPIWrapper(tavily_api_key=settings.TAVILY_API_KEY)
+        )
+        
+        self.vector_search = FAISSVectorSearch()
+
+    def process(self, query: str) -> ContextInfo:
+        """Gather context from multiple sources"""
+        web_context = self._get_web_context(query)
+        vector_context = self._get_vector_context(query)
+
+        combined_context = f"{web_context}\n\n{vector_context}"
+        
+        self._log_action(action="context_gathered", metadata={"query": query, "web_context": web_context, "vector_context": vector_context}, level=logging.INFO)  
+        return ContextInfo(
+            query=query,
+            web_context=web_context,
+            vector_context=vector_context,
+            combined_context=combined_context,
+        )
+    
+    def _get_web_context(self, query: str) -> str:
+        try:
+            results = self.web_search.invoke(query)
+            return "\n".join([res["content"] for res in results])
+        except Exception as e:
+            self._log_action(action="web_search_error", metadata={"error": str(e)}, level=logging.ERROR)
+            return "Web search unavailable"
+    
+    def _get_vector_context(self, query: str) -> str:
+        try:
+            return self.vector_search.search(query)
+        except Exception as e:
+            self._log_action(action="vector_search_error", metadata={"error": str(e)}, level=logging.ERROR)
+            return "Vector search unavailable"
+
+
+    async def process_async(self, query: str) -> ContextInfo:
+        return await asyncio.get_event_loop().run_in_executor(
+        None,
+        lambda: self.process(query)
+    )

src/llm/agents/conversation_agent.py

@@ -0,0 +1,205 @@
+import uuid
+import textwrap
+import logging
+import asyncio
+from typing import Dict, Any, Optional, List
+from src.llm.agents.base_agent import BaseAgent
+from src.llm.agents.emotion_agent import EmotionAgent
+from src.llm.agents.context_agent import ContextAgent
+from src.llm.models.schemas import ConversationResponse, EmotionalAnalysis, ContextInfo
+from src.llm.models.schemas import SessionData
+from src.llm.memory.memory_manager import RedisMemoryManager
+from src.llm.memory.session_manager import SessionManager
+from src.llm.memory.history import RedisHistory
+
+class ConversationAgent(BaseAgent):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.emotion_agent = EmotionAgent(llm=self.llm, history=self.history)
+        self.context_agent = ContextAgent(llm=self.llm, history=self.history)
+        self.memory_manager = RedisMemoryManager()
+        self.session_manager = SessionManager()
+        self.history = RedisHistory()
+    
+    def process(
+        self,
+        query: str,
+        session_data: Optional[SessionData] = None
+    ) -> ConversationResponse:
+        """Process user query with emotional awareness and context"""
+        # Generate or validate IDs
+        if session_data:
+            user_id = self.session_manager.validate_session(session_data.session_id)
+            if user_id:
+                # Existing valid session
+                session_id = session_data.session_id
+                is_new_session = False
+            else:
+                # Expired session, create new
+                user_id, session_id = self.session_manager.generate_ids(session_data.user_id)
+                is_new_session = True
+        else:
+            # New conversation
+            user_id, session_id = self.session_manager.generate_ids()
+            is_new_session = True
+
+        chat_id = str(uuid.uuid4())
+        # Analyze emotion
+        emotion_analysis = self.emotion_agent.process(query)
+        
+        # Gather context
+        context = self.context_agent.process(query)
+        context = ContextInfo(
+            query=context.query,
+            web_context=context.web_context,
+            vector_context=context.vector_context,
+            combined_context=context.combined_context
+        )
+
+        history_context= self.history.get_full_context(session_id)
+        
+        combined_context = context.combined_context if context else None
+        
+        # Generate response
+        response = self._generate_response(
+            query=query,
+            emotion_analysis=emotion_analysis,
+            context=combined_context,
+            chat_history=history_context
+        )
+        
+        conversation_response = ConversationResponse(
+            session_data=SessionData(
+                user_id=user_id,
+                session_id=session_id,
+                is_new_user=(session_data is None),
+                is_new_session=is_new_session
+            ),
+            response=response,
+            emotion_analysis=emotion_analysis,
+            context=context,
+            query=query,
+            safety_level="unknown",
+            suggested_resources=[]
+        )
+
+        self.memory_manager.store_conversation(session_id, chat_id, conversation_response)
+        self.history.add_conversation(session_id, chat_id, conversation_response)
+
+        self._log_action(action="conversation", metadata={"query": query, "response": response}, level=logging.INFO, session_id=session_id, user_id=user_id)
+        
+        return conversation_response
+    
+    def _generate_response(
+        self,
+        query: str,
+        emotion_analysis: Optional[EmotionalAnalysis],
+        context: Optional[ContextInfo],
+        chat_history: Optional[List[Dict]]
+    ) -> str:
+        
+        prompt = self._construct_response_prompt(
+            query=query,
+            emotion_analysis=emotion_analysis,
+            context=context,
+            chat_history=chat_history
+        )
+        
+        response = self.llm.generate(prompt)
+        return response.content.strip()
+    
+    def _construct_response_prompt(self, **kwargs) -> str:
+        # Implement sophisticated prompt construction
+        prompt = f"""
+                You are Thery AI, a compassionate virtual therapist who provides supportive, evidence-based advice and empathetic conversation. Your goal is to create a safe, non-judgmental, and empathetic environment for users to share their concerns. When generating your response, follow these steps internally:
+
+                Chain of Thoughts:
+
+                1. Acknowledge the Emotional State:
+                - Identify and validate the emotion expressed by the user.
+                - Use language that shows understanding and empathy.
+
+                2. Select Relevant Therapeutic Approach:
+                - Consider the user's concern, emotional state, and context to determine the most suitable therapeutic modality (e.g., Cognitive-Behavioral Therapy (CBT), Mindfulness-Based Stress Reduction (MBSR), Acceptance and Commitment Therapy (ACT), or Psychodynamic Therapy).
+                - Tailor your response to incorporate principles and techniques from the chosen approach.
+
+                3. Provide Evidence-Based Support:
+                - Incorporate relevant research or common therapeutic techniques where applicable.
+                - Ensure that your advice is grounded in best practices.
+
+                4. Incorporate Context Appropriately:
+                - Use the provided context (from previous interactions or additional background) to make your response more personalized and relevant.
+
+                5. Maintain a Supportive and Empathetic Tone:
+                - Craft your response as if you were speaking with a friend who cares deeply about the user’s well-being.
+                - Avoid clinical jargon; use accessible, warm, and encouraging language.
+
+                6. Include Specific Coping Strategies When Appropriate:
+                - Offer actionable suggestions (like deep breathing, mindfulness, journaling, or seeking additional support) that the user can try.
+                - Ask gentle follow-up questions to invite the user to share more, if needed.
+
+                Key Attributes:
+
+                1. Empathy: Understand and share feelings with users.
+                2. Active listening: Give full attention to users, understanding their concerns, and responding thoughtfully.
+                3. Non-judgmental: Avoid criticism or judgment, creating a safe and accepting environment.
+                4. Confidentiality: Maintain users' trust by keeping their information private.
+                5. Cultural competence: Understand and respect users' diverse backgrounds, values, and beliefs.
+
+                Conversation Guidelines:
+
+                1. Begin with an open-ended question to encourage users to share their concerns.
+                2. Use reflective listening to ensure understanding and show empathy.
+                3. Avoid giving direct advice; instead, guide users to explore their own thoughts and feelings.
+                4. Focus on empowering users to make their own decisions.
+                5. Manage conversations to maintain a calm and composed tone.
+
+                Important Instructions:
+
+                1. Do not attempt to diagnose or treat mental health conditions. You are not a licensed therapist.
+                2. Avoid providing explicit or graphic responses.
+                3. Do not share personal experiences or opinions.
+                4. Maintain a neutral and respectful tone.
+                5. If a user expresses suicidal thoughts or intentions, provide resources for immediate support (e.g., crisis hotlines, emergency services).
+
+                Example Response:
+
+                User: "I'm feeling overwhelmed with work and personal life."
+
+                You: "I can sense your frustration. Can you tell me more about what's been going on, and how you've been coping with these challenges?"
+
+                Please respond as a therapist would, using the guidelines and attributes above.
+
+                Input Variables:
+
+                - Chat History: {kwargs['chat_history']}
+                - User Query: {kwargs['query']}
+                - Emotional Analysis: {kwargs['emotion_analysis']}
+                - Context: {kwargs['context']}
+
+                Response Example:
+
+                - If the user says, “Hello,” start with a friendly greeting: "Hi there, I'm Thery AI. How can I help you today?"
+                - If the user later says, “I feel sad,” continue with: "I'm sorry to hear you're feeling sad. Can you tell me a bit more about what's been going on? Sometimes sharing details can help in understanding and easing your feelings."
+
+                User: "I'm feeling overwhelmed with work and personal life."
+
+                You: "I can sense your frustration. Can you tell me more about what's been going on, and how you've been coping with these challenges?"
+
+                Please respond as a therapist would, using the guidelines and attributes above. Make sure your responses are not overly long. BE NATURAL, SUUPPORTIVE, AND EMPHATIZING
+                
+                """
+
+        return textwrap.dedent(prompt).strip()
+
+    
+    async def process_async(
+        self,
+        query: str,
+        session_data: Optional[SessionData] = None
+    ) -> ConversationResponse:
+        
+        return await asyncio.get_event_loop().run_in_executor(
+        None,
+        lambda: self.process(query, session_data)
+    )

src/llm/agents/emotion_agent.py

@@ -0,0 +1,125 @@
+import textwrap
+import asyncio
+from typing import Dict, Any
+import logging
+from .base_agent import BaseAgent
+from src.llm.models.schemas import EmotionalAnalysis
+
+class EmotionAgent(BaseAgent):
+    def process(self, text: str) -> EmotionalAnalysis:
+        """Process text for emotional content"""
+        prompt = self._construct_emotion_prompt(text)
+        response = self.llm.generate(prompt)
+        analysis = self._parse_emotion_response(response.content)
+        self._log_action(action="emotion_analysis", metadata={"text": text, "analysis": analysis}, level=logging.INFO)
+        
+        return EmotionalAnalysis(
+            primary_emotion=analysis['primary_emotion'],
+            intensity=analysis['intensity'],
+            secondary_emotions=analysis['secondary_emotions'],
+            triggers=analysis['emotional_triggers'],
+            coping_strategies=analysis['coping_strategies'],
+            confidence_score=analysis['confidence_score']
+        )
+    
+    def _construct_emotion_prompt(self, text: str) -> str:
+        emotion_prompt = f"""
+            Analyze the emotional content in the following text:
+            Text: {text}
+            
+            Provide analysis in the following format:
+            1. Primary emotion: [single emotion]
+            2. Intensity: [number between 1 and 10]
+            3. Secondary emotions: [comma-separated list of emotions]
+            4. Emotional triggers: [comma-separated list of triggers]
+            5. Suggested coping strategies: [comma-separated list of strategies]
+            6. Confidence score: [number between 0 and 1]
+            
+            Example:
+            1. Primary emotion: Anxiety
+            2. Intensity: 7
+            3. Secondary emotions: Fear, Worry
+            4. Emotional triggers: Work deadline, Family conflict
+            5. Suggested coping strategies: Deep breathing, Journaling, Talking to a friend
+            6. Confidence score: 0.8
+        """
+        
+        return textwrap.dedent(emotion_prompt).strip()
+    
+    def _parse_emotion_response(self, response: str) -> dict:
+        try:
+            analysis = {
+                'primary_emotion': '',
+                'intensity': 0,
+                'secondary_emotions': [],
+                'emotional_triggers': [],
+                'coping_strategies': [],
+                'confidence_score': 0.0
+            }
+            
+            for line in response.split('\n'):
+                # Convert the line to string explicitly in case it's not
+                line = str(line).strip()
+                if not line:
+                    continue
+                    
+                # Split on first colon only
+                parts = line.split(':', 1)
+                if len(parts) != 2:
+                    continue
+
+                
+                self._log_action(action="emotion_analysis_debug", metadata={"line":line}, level=logging.DEBUG)
+
+                # Ensure key is a string before calling lower()
+                key = str(parts[0]).strip().lower()  # Explicitly convert to string
+                value = str(parts[1]).strip()
+                
+                self._log_action(action="emotion_analysis_debug", metadata={"line":line, "key": key, "value": value}, level=logging.DEBUG)
+
+                if 'primary emotion' in key:
+                    analysis['primary_emotion'] = value
+                elif 'intensity' in key:
+                    # Convert intensity to integer safely
+                    try:
+                        analysis['intensity'] = int(value.strip('[]'))
+                    except ValueError:
+                        analysis['intensity'] = 5  # default value
+                elif 'secondary emotions' in key:
+                    analysis['secondary_emotions'] = [
+                        s.strip() for s in value.split(',') if s.strip()
+                    ]
+                elif 'emotional triggers' in key:
+                    analysis['emotional_triggers'] = [
+                        t.strip() for t in value.split(',') if t.strip()
+                    ]
+                elif 'suggested coping strategies' in key:
+                    analysis['coping_strategies'] = [
+                        c.strip() for c in value.split(',') if c.strip()
+                    ]
+                elif 'confidence score' in key:
+                    # Convert confidence score to float safely
+                    try:
+                        analysis['confidence_score'] = float(value.strip('[]'))
+                    except ValueError:
+                        analysis['confidence_score'] = 0.5
+                    
+            if not analysis['primary_emotion']:
+                raise ValueError("Primary emotion not found in response")
+            
+            self._log_action(action="emotion_analysis_success", metadata={"response": response, "analysis": analysis}, level=logging.INFO)
+            return analysis
+                
+        except Exception as e:
+            self._log_action(
+                action="emotion_analysis_error", 
+                metadata={"response": str(response), "error": str(e)},
+                level=logging.ERROR
+            )
+            raise ValueError(f"Failed to parse emotion response: {str(e)}")
+        
+    async def process_async(self, text: str) -> EmotionalAnalysis:
+        return await asyncio.get_event_loop().run_in_executor(
+            None,
+            lambda: self.process(text)
+        )

src/llm/core/config.py

@@ -0,0 +1,36 @@
+from dotenv import load_dotenv
+import os
+from pydantic_settings import BaseSettings
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    GOOGLE_API_KEY: str = os.getenv("GOOGLE_API_KEY")
+    TAVILY_API_KEY: str = os.getenv("TAVILY_API_KEY")
+    REDIS_HOST: str = "localhost"
+    REDIS_PORT: int = 6379
+    REDIS_DB: int = 0
+    REDIS_USER: str = "redis"
+    REDIS_PASSWORD: str = ""
+    SESSION_TTL: int = 86400
+    MAX_RETRIES: int = 3
+    MAX_TOKENS: int = 200
+    SAFETY_THRESHOLD: float = 0.95
+    TAVILY_MAX_RESULTS: int = 3
+    TAVILY_INCLUDE_IMAGES: bool = False
+    TAVILY_INCLUDE_ANSWER: bool = True
+    LANGCHAIN_API_KEY: str = os.getenv("LANGCHAIN_API_KEY")
+    LANGCHAIN_TRACING_V2: str = os.getenv("LANGCHAIN_TRACING_V2")
+    LANGCHAIN_ENDPOINT: str = os.getenv("LANGCHAIN_ENDPOINT")
+    LANGSMITH_API_KEY: str = os.getenv("LANGSMITH_API_KEY")
+    OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY")
+    CLAUDE_API_KEY: str = os.getenv("CLAUDE_API_KEY")
+    SPOTIFY_CLIENT_ID: str = os.getenv("SPOTIFY_CLIENT_ID")
+    SPOTIFY_CLIENT_SECRET: str = os.getenv("SPOTIFY_CLIENT_SECRET")
+    SPOTIFY_REDIRECT_URI: str = os.getenv("SPOTIFY_REDIRECT_URI")
+    TELEGRAM_BOT_TOKEN: str = os.getenv("TELEGRAM_BOT_TOKEN")
+    
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

src/llm/core/llm.py

@@ -0,0 +1,107 @@
+from typing import Optional, Dict, Any
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.messages import AIMessage
+import logging
+from src.llm.core.config import settings
+from src.llm.utils.logging import TheryBotLogger
+
+class LLMError(Exception):
+    """Custom exception for LLM-related errors"""
+    pass
+
+class TheryLLM:
+    """Enhanced LLM wrapper with safety checks and response validation"""
+    
+    def __init__(
+        self,
+        model_name: str = "gemini-1.5-flash",
+        temperature: float = 0.3,
+        max_retries: int = 3,
+        safety_threshold: float = 0.75,
+        logger: Optional[TheryBotLogger] = None
+    ):
+        self.model_name = model_name
+        self.temperature = temperature
+        self.max_retries = max_retries
+        self.safety_threshold = safety_threshold
+        self.logger = logger or TheryBotLogger()
+        self._initialize_llm()
+    
+    def _initialize_llm(self) -> None:
+        """Initialize the LLM with proper error handling"""
+        try:
+            self.llm = ChatGoogleGenerativeAI(
+                model=self.model_name,
+                temperature=self.temperature,
+                max_retries=self.max_retries,
+                google_api_key=settings.GOOGLE_API_KEY,
+                max_tokens= settings.MAX_TOKENS
+            )
+            self._session_active = True
+        except Exception as e:
+            self._session_active = False
+            self.logger.log_interaction(
+                interaction_type="llm_initialization_failed",
+                data={"error": str(e)},
+                level=logging.ERROR
+            )
+            raise LLMError(f"LLM initialization failed: {str(e)}")
+    
+    def generate(self, prompt: str, **kwargs) -> AIMessage:
+        """Generate a response with safety checks and validation"""
+        if not self._session_active:
+            self._initialize_llm()
+        
+        try:
+            # Log the generation attempt
+            self.logger.log_interaction(
+                interaction_type="llm_generation_attempt",
+                data={"prompt": prompt, "kwargs": kwargs},
+                level=logging.INFO
+            )
+            
+            # Generate response
+            response = self.llm.invoke(prompt)
+            
+            # Validate response
+            validated_response = self._validate_response(response)
+            
+            # Log successful generation
+            self.logger.log_interaction(
+                interaction_type="llm_generation_success",
+                data={"prompt": prompt, "response": str(validated_response)},
+                level=logging.INFO
+            )
+            
+            return validated_response
+            
+        except Exception as e:
+            self.logger.log_interaction(
+                interaction_type="llm_generation_error",
+                data={"prompt": prompt, "error": str(e)},
+                level=logging.ERROR
+            )
+            raise LLMError(f"Generation failed: {str(e)}")
+    
+    def _validate_response(
+        self,
+        response: AIMessage
+    ) -> AIMessage:
+        """Validate response content and format"""
+        if not isinstance(response, AIMessage):
+            self.logger.log_interaction(
+                interaction_type="llm_invalid_response_type",
+                data={"response": response},
+                level=logging.ERROR
+            )
+            raise LLMError("Invalid response type")
+            
+        if not response.content.strip():
+            self.logger.log_interaction(
+                interaction_type="llm_empty_response",
+                data={"response": response},
+                level=logging.ERROR
+            )
+            raise LLMError("Empty response content")
+            
+        return response

src/llm/main.py

@@ -0,0 +1,46 @@
+import logging
+from src.llm.agents.conversation_agent import ConversationAgent
+from src.llm.utils.logging import TheryBotLogger
+from src.llm.core.config import settings
+
+def main():
+    # Initialize logger
+    logger = TheryBotLogger()
+    
+    # Initialize main conversation agent
+    agent = ConversationAgent()
+    
+    # Example interaction
+    query = "But I have been try to do this for quite a while now and I am still not able to get it right."
+    
+    try:
+        # Process query
+        response = agent.process(query)
+        
+        # Log interaction
+        logger.log_interaction(
+            interaction_type="user_interaction",
+            data={
+                "query": query,
+                "response": response.response,
+                "status": "success"
+            },
+            level=logging.INFO
+        )
+        
+        # Print response
+        print(f"Thery AI: {response.response}")
+        
+    except Exception as e:
+        logger.log_interaction(
+            interaction_type="error",
+            data={
+                "query": query,
+                "error": str(e)
+            },
+            level=logging.ERROR
+        )
+        print("An error occurred. Please try again.")
+
+if __name__ == "__main__":
+    main()

src/llm/memory/history.py

@@ -0,0 +1,67 @@
+import json
+import time
+from datetime import timedelta
+from typing import List, Dict, Any, Optional
+from .redis_connection import RedisConnection
+from src.llm.models.schemas import ConversationResponse
+from src.llm.core.config import settings
+
+class RedisHistory:
+    def __init__(self, session_ttl: int = settings.SESSION_TTL):
+        self.redis = RedisConnection().client
+        self.session_ttl = session_ttl
+
+    def add_conversation(self, session_id: str, chat_id: str, response: ConversationResponse) -> None:
+        """
+        Store complete conversation response in history
+        """
+        # Store in session-specific list
+        self.redis.rpush(
+            f"session:{session_id}:history",
+            json.dumps({
+                'chat_id': chat_id,
+                'response': response.dict(),
+                'timestamp': time.time()
+            })
+        )
+        
+        # Set TTL for session history
+        self.redis.expire(f"session:{session_id}:history", self.session_ttl)
+    
+    def get_conversation_history(self, session_id: str, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Retrieve conversation history with optional limit
+        """
+        messages = self.redis.lrange(f"session:{session_id}:history", -limit, -1)
+        return [
+            {
+                'chat_id': json.loads(msg)['chat_id'],
+                'response': ConversationResponse(**json.loads(msg)['response']),
+                'timestamp': json.loads(msg)['timestamp']
+            }
+            for msg in messages
+        ]
+    
+    def get_full_context(self, session_id: str) -> str:
+        """
+        Generate conversation context string for LLM prompts
+        """
+        history = self.get_conversation_history(session_id)
+        context_lines = []
+        
+        for entry in history:
+            response = entry['response']
+            context_lines.append(
+                f"User: {response.query}\n"
+                f"Therapist: {response.response}\n"
+                f"Emotions: {response.emotion_analysis.primary_emotion} "
+                f"(Intensity: {response.emotion_analysis.intensity})\n"
+            )
+        
+        return "\n".join(context_lines)
+    
+    def clear_history(self, session_id: str) -> None:
+        """
+        Clear session history
+        """
+        self.redis.delete(f"session:{session_id}:history")

src/llm/memory/memory_manager.py

@@ -0,0 +1,71 @@
+from typing import Dict, Any, Optional
+from .redis_connection import RedisConnection
+from src.llm.models.schemas import ConversationResponse
+import json
+import time
+
+class RedisMemoryManager:
+    def __init__(self):
+        self.redis = RedisConnection().client
+    
+    def store_conversation(self, session_id: str, chat_id: str, response: ConversationResponse) -> None:
+        """
+        Store complete conversation response with metadata
+        """
+        response_data = response.dict()
+        timestamp = time.time()
+        
+        # Store in session-specific hash
+        self.redis.hset(
+            f"session:{session_id}:chats",
+            chat_id,
+            json.dumps({
+                'response': response_data,
+                'timestamp': timestamp
+            })
+        )
+        
+        # Update session metadata
+        self.redis.hset(
+            f"session:{session_id}",
+            mapping={
+                'last_chat_id': chat_id,
+                'last_updated': str(timestamp)
+            }
+        )
+    
+    def get_conversation(self, session_id: str, chat_id: str) -> Optional[ConversationResponse]:
+        """
+        Retrieve specific conversation response
+        """
+        data = self.redis.hget(f"session:{session_id}:chats", chat_id)
+        if data:
+            return ConversationResponse(**json.loads(data)['response'])
+        return None
+    
+    def get_session_conversations(self, session_id: str) -> Dict[str, Any]:
+        """
+        Get all conversations for a session
+        """
+        conversations = self.redis.hgetall(f"session:{session_id}:chats")
+        return {
+            chat_id: ConversationResponse(**json.loads(data)['response'])
+            for chat_id, data in conversations.items()
+        }
+    
+    def update_emotional_state(self, session_id: str, emotions: Dict[str, Any]) -> None:
+        """
+        Update emotional state tracking
+        """
+        self.redis.hset(
+            f"session:{session_id}:state",
+            'emotions',
+            json.dumps(emotions)
+        )
+    
+    def get_emotional_state(self, session_id: str) -> Dict[str, Any]:
+        """
+        Retrieve current emotional state
+        """
+        data = self.redis.hget(f"session:{session_id}:state", 'emotions')
+        return json.loads(data) if data else {}

src/llm/memory/redis_connection.py

@@ -0,0 +1,38 @@
+import redis
+import logging
+from src.llm.core.config import settings
+from src.llm.utils.logging import TheryBotLogger
+
+class RedisConnection:
+    _instance = None
+    
+    def __new__(cls):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialize_self()
+        return cls._instance
+    
+    def _initialize_self(self) -> None:
+        self.logger = TheryBotLogger()
+        self.redis = redis.Redis(
+            host=settings.REDIS_HOST,
+            port=settings.REDIS_PORT,
+            db=settings.REDIS_DB,
+            password=settings.REDIS_PASSWORD,
+            decode_responses=True
+        )
+        try:
+            self.redis.ping()
+        except redis.ConnectionError as e:
+            self.logger.log_interaction(
+                interaction_type="redis_connection_failed",
+                data={"error": str(e)},
+                level=logging.ERROR
+            )
+            raise RuntimeError(f"Redis connection failed: {str(e)}")
+
+    @property
+    def client(self):
+        if not self.redis.ping():
+            self._initialize_self()
+        return self.redis

src/llm/memory/session_manager.py

@@ -0,0 +1,48 @@
+import time
+import uuid
+from typing import Optional, Tuple
+from .redis_connection import RedisConnection
+from src.llm.core.config import settings
+
+class SessionManager:
+    def __init__(self):
+        self.redis = RedisConnection().client
+        
+    def generate_ids(self, existing_user_id: Optional[str] = None) -> Tuple[str, str]:
+        """
+        Generate or validate user/session IDs
+        Returns: (user_id, session_id)
+        """
+        user_id = self._get_or_create_user_id(existing_user_id)
+        session_id = self._create_session(user_id)
+        return user_id, session_id
+
+    def _get_or_create_user_id(self, existing_user_id: Optional[str]) -> str:
+        if existing_user_id:
+            if self.redis.exists(f"user:{existing_user_id}"):
+                return existing_user_id
+            # If invalid existing ID, generate new
+            return str(uuid.uuid4())
+        return str(uuid.uuid4())
+
+    def _create_session(self, user_id: str) -> str:
+        session_id = str(uuid.uuid4())
+        # Store session metadata
+        self.redis.hset(f"session:{session_id}", mapping={
+            "user_id": user_id,
+            "created_at": str(time.time()),
+            "activity": str(time.time())
+        })
+        # Set TTL (24 hours by default)
+        self.redis.expire(f"session:{session_id}", settings.SESSION_TTL)
+        # Link to user
+        self.redis.sadd(f"user:{user_id}:sessions", session_id)
+        return session_id
+
+    def validate_session(self, session_id: str) -> Optional[str]:
+        """Returns user_id if valid session"""
+        if self.redis.exists(f"session:{session_id}"):
+            # Update last activity
+            self.redis.hset(f"session:{session_id}", "activity", str(time.time()))
+            return self.redis.hget(f"session:{session_id}", "user_id")
+        return None

src/llm/memory/vector_store.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+from typing import List, Optional
+import logging
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from src.llm.utils.logging import TheryBotLogger
+
+class FAISSVectorSearch:
+    def __init__(
+        self,
+        embedding_model: Optional[HuggingFaceEmbeddings] = None,
+        db_path: Path = Path("vector_embedding/mental_health_vector_db"),
+        k: int = 5,
+        logger: Optional[TheryBotLogger] = None
+    ):
+        self.embedding_model = embedding_model or self._get_default_embedding_model()
+        self.db_path = db_path
+        self.k = k
+        self.logger = logger or TheryBotLogger()
+        self._initialize_store()
+    
+    def _get_default_embedding_model(self) -> HuggingFaceEmbeddings:
+        return HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-MiniLM-L6-v2",
+            model_kwargs={"device": "cpu"},
+            encode_kwargs={
+                "padding": "max_length",
+                "max_length": 512,
+                "truncation": True,
+                "normalize_embeddings": True
+            }
+        )
+    
+    def _initialize_store(self) -> None:
+        if self.db_path.exists():
+            self.vectorstore = FAISS.load_local(
+                str(self.db_path),
+                self.embedding_model,
+                allow_dangerous_deserialization=True
+            )
+        else:
+            # Initialize with empty store
+            self.vectorstore = FAISS.from_texts(
+                [""], self.embedding_model
+            )
+    
+    def search(self, query: str, k: Optional[int] = None) -> List[str]:
+        try:
+            results = self.vectorstore.similarity_search(
+                query,
+                k=(k or self.k)
+            )
+            return [res.page_content for res in results]
+        except Exception as e:
+            # Log error and return empty results
+            self.logger.log_interaction(
+                interaction_type="vector_search_error",
+                data={"error": str(e)},
+                level=logging.ERROR
+            )
+            return []
+    
+    def add_texts(self, texts: List[str]) -> None:
+        """Add new texts to the vector store"""
+        self.vectorstore.add_texts(texts)
+        # Optionally save after adding
+        self.save()
+    
+    def save(self) -> None:
+        """Save the vector store to disk"""
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.vectorstore.save_local(str(self.db_path))

src/llm/models/schemas.py

@@ -0,0 +1,31 @@
+from pydantic import BaseModel, Field
+from typing import Dict, Any, Optional, List
+
+class EmotionalAnalysis(BaseModel):
+    primary_emotion: str
+    intensity: int = Field(..., ge=1, le=10)
+    secondary_emotions: List[str]
+    triggers: List[str]
+    coping_strategies: List[str] = []
+    confidence_score: float = Field(..., ge=0, le=1)
+
+class ContextInfo(BaseModel):
+    query: str
+    web_context: str = ""
+    vector_context: List[str] = Field(default_factory=list)
+    combined_context: str = ""
+
+class SessionData(BaseModel):
+    user_id: str = Field(..., description="Unique user identifier")
+    session_id: str = Field(..., description="Current session identifier")
+    is_new_user: bool = Field(False, description="Flag for new user detection")
+    is_new_session: bool = Field(False, description="Flag for new session detection")
+
+class ConversationResponse(BaseModel):
+    session_data: SessionData
+    response: str = Field(..., description="Primary assistant response")
+    emotion_analysis: EmotionalAnalysis
+    context: ContextInfo = Field(default_factory=ContextInfo)
+    query: str
+    safety_level: str = Field("unknown", description="Assessment of response safety")  # Default value
+    suggested_resources: List[str] = Field(default_factory=list)

src/llm/routes.py

@@ -0,0 +1,179 @@
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
+from fastapi.responses import JSONResponse
+from typing import List, Optional
+from datetime import datetime
+
+from src.llm.agents.conversation_agent import ConversationAgent
+from src.llm.models.schemas import ConversationResponse, SessionData
+from src.llm.utils.logging import TheryBotLogger
+from src.llm.memory.history import RedisHistory
+from src.llm.memory.memory_manager import RedisMemoryManager
+from src.llm.memory.session_manager import SessionManager
+from src.llm.core.config import settings
+
+router = APIRouter(
+    prefix="/api/v1",
+    tags=["TheryAI Services"],
+    responses={
+        200: {"description": "Success"},
+        400: {"description": "Bad Request"},
+        404: {"description": "Not found"},
+        500: {"description": "Internal Server Error"}
+    },
+)
+
+# Initialize managers
+session_manager = SessionManager()
+memory_manager = RedisMemoryManager()
+history = RedisHistory()
+logger = TheryBotLogger()
+conversation_agent = ConversationAgent()
+
+@router.post("/users", response_model=dict)
+async def create_user():
+    """Create a new user and return user_id"""
+    try:
+        user_id, _ = session_manager.generate_ids()
+        return {"user_id": user_id}
+    except Exception as e:
+        logger.error(f"Error creating user: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to create user")
+
+@router.get("/users/{user_id}/sessions", response_model=List[dict])
+async def get_user_sessions(user_id: str):
+    """Get all sessions for a user"""
+    try:
+        sessions = session_manager.get_user_sessions(user_id)
+        return sessions
+    except Exception as e:
+        logger.error(f"Error fetching sessions for user {user_id}: {str(e)}")
+        raise HTTPException(status_code=404, detail="User not found")
+
+@router.post("/sessions", response_model=SessionData)
+async def create_session(user_id: Optional[str] = None):
+    """Create a new session"""
+    try:
+        user_id, session_id = session_manager.generate_ids(existing_user_id=user_id)
+        return SessionData(
+            user_id=user_id,
+            session_id=session_id,
+            is_new_user=(user_id is None),
+            is_new_session=True
+        )
+    except Exception as e:
+        logger.error(f"Error creating session: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to create session")
+
+@router.get("/sessions/{session_id}", response_model=SessionData)
+async def get_session(session_id: str):
+    """Get session metadata"""
+    try:
+        user_id = session_manager.validate_session(session_id)
+        if not user_id:
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        return SessionData(
+            user_id=user_id,
+            session_id=session_id,
+            is_new_user=False,
+            is_new_session=False
+        )
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        logger.error(f"Error fetching session {session_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to fetch session")
+
+@router.get("/sessions/{session_id}/messages", response_model=List[ConversationResponse])
+async def get_session_messages(
+    session_id: str,
+    limit: Optional[int] = 10
+):
+    """Get messages from a session"""
+    try:
+        if not session_manager.validate_session(session_id):
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        messages = history.get_conversation_history(session_id, limit=limit)
+        return [msg["response"] for msg in messages]
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        logger.error(f"Error fetching messages for session {session_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to fetch messages")
+
+@router.post("/sessions/{session_id}/messages", response_model=ConversationResponse)
+async def create_message(
+    session_id: str,
+    message: str,
+    background_tasks: BackgroundTasks
+):
+    """Create a new message in a session"""
+    try:
+        user_id = session_manager.validate_session(session_id)
+        if not user_id:
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        session_data = SessionData(
+            user_id=user_id,
+            session_id=session_id,
+            is_new_user=False,
+            is_new_session=False
+        )
+        
+        response = await conversation_agent.process_async(
+            query=message,
+            session_data=session_data
+        )
+        
+        # Store conversation asynchronously
+        background_tasks.add_task(
+            memory_manager.store_conversation,
+            session_id,
+            str(datetime.now().timestamp()),
+            response
+        )
+        
+        return response
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        logger.error(f"Error processing message in session {session_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to process message")
+
+@router.get("/sessions/{session_id}/memory", response_model=dict)
+async def get_session_memory(session_id: str):
+    """Get all memory data for a session"""
+    try:
+        if not session_manager.validate_session(session_id):
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        conversations = memory_manager.get_session_conversations(session_id)
+        emotional_state = memory_manager.get_emotional_state(session_id)
+        
+        return {
+            "conversations": conversations,
+            "emotional_state": emotional_state
+        }
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        logger.error(f"Error fetching memory for session {session_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to fetch memory")
+
+@router.delete("/sessions/{session_id}", response_model=dict)
+async def end_session(session_id: str):
+    """End a session and clean up resources"""
+    try:
+        if not session_manager.validate_session(session_id):
+            raise HTTPException(status_code=404, detail="Session not found")
+        
+        history.clear_history(session_id)
+        session_manager.end_session(session_id)
+        
+        return {"message": "Session ended successfully"}
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        logger.error(f"Error ending session {session_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to end session")

src/llm/utils/logging.py

@@ -0,0 +1,54 @@
+import logging
+import json
+from datetime import datetime
+from typing import Any, Dict
+from pathlib import Path
+
+class TheryBotLogger:
+    def __init__(self, log_dir: Path = Path("logs")):
+        self.log_dir = log_dir
+        self._setup_logging()
+    
+    def _setup_logging(self) -> None:
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Setup file handler
+        file_handler = logging.FileHandler(
+            self.log_dir / f"thery_bot_{datetime.now():%Y%m%d}.log"
+        )
+        file_handler.setLevel(logging.INFO)
+        
+        # Setup console handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.WARNING)
+        
+        # Setup formatters
+        file_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        console_formatter = logging.Formatter(
+            '%(levelname)s: %(message)s'
+        )
+        
+        file_handler.setFormatter(file_formatter)
+        console_handler.setFormatter(console_formatter)
+        
+        # Setup root logger
+        logging.root.setLevel(logging.INFO)
+        logging.root.addHandler(file_handler)
+        logging.root.addHandler(console_handler)
+    
+    def log_interaction(
+        self,
+        interaction_type: str,
+        data: Dict[str, Any],
+        level: int = logging.INFO
+    ) -> None:
+        """Log an interaction with structured data"""
+        log_entry = {
+            "timestamp": datetime.now().isoformat(),
+            "type": interaction_type,
+            "data": data
+        }
+        
+        logging.log(level, json.dumps(log_entry))

src/music/clients/spotify_client.py

@@ -0,0 +1,76 @@
+from spotipy import Spotify
+from spotipy.oauth2 import SpotifyClientCredentials
+from typing import Dict, List
+from src.music.config.settings import SpotifyConfig, logger
+from src.music.models.data_models import RecommendationParameters
+
+class SpotifyClient:
+    """Handles Spotify authentication and API operations"""
+
+    def __init__(self, config: SpotifyConfig):
+        self.config = config
+        self.config.validate()
+        self.authenticate()
+
+    def authenticate(self):
+        """Authenticate and set up the Spotify client"""
+        self.client_credentials_manager = SpotifyClientCredentials(
+            client_id=self.config.client_id,
+            client_secret=self.config.client_secret
+        )
+        self.client = Spotify(client_credentials_manager=self.client_credentials_manager)
+
+    def get_recommendations(self, params: RecommendationParameters) -> List[Dict]:
+        """Get track recommendations from Spotify"""
+        try:
+            response = self.client.recommendations(
+                seed_genres=params.seed_genres,
+                target_features=params.target_features,
+                limit=params.limit,
+                market=params.market
+            )
+            return response['tracks']
+        except Exception as e:
+            logger.error(f"Recommendation failed: {str(e)}")
+            raise
+
+    def refresh_authentication(self):
+        """Refresh authentication and reinitialize the client"""
+        try:
+            self.authenticate()
+        except Exception as e:
+            logger.error(f"Failed to refresh authentication: {str(e)}")
+            raise
+
+    def get_available_genres(self) -> List[str]:
+        """Get available genre seeds from Spotify"""
+        try:
+            self.refresh_authentication()  # Ensure fresh authentication
+            response = self.client.recommendation_genre_seeds()
+            logger.info(f"Available genres: {response}")
+            return response.get('genres', [])
+        except Exception as e:
+            logger.error(f"Failed to fetch genres: {str(e)}")
+            return []
+
+    def get_audio_features(self, track_uri: str) -> Dict:
+        """Get audio features for a track"""
+        try:
+            return self.client.audio_features(track_uri)[0] or {}
+        except Exception as e:
+            logger.error(f"Failed to fetch audio features: {str(e)}")
+            return {}
+
+
+# Usage:
+spotify_client = SpotifyClient(config=SpotifyConfig())
+params = RecommendationParameters(
+    seed_genres=["pop", "rock"], 
+    target_features={"danceability": 0.7, "energy": 0.6},
+    limit=10,
+    market="US"
+)
+
+print(params)  # Debugging
+recommendations = spotify_client.get_recommendations(params)
+print(recommendations)

src/music/config/settings.py

@@ -0,0 +1,22 @@
+import os
+from dataclasses import dataclass
+from dotenv import load_dotenv
+import logging
+
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SpotifyConfig:
+    client_id: str = os.getenv("SPOTIFY_CLIENT_ID")
+    client_secret: str = os.getenv("SPOTIFY_CLIENT_SECRET")
+    market: str = "US"
+    max_retries: int = 3
+    
+    def validate(self):
+        if not self.client_id or not self.client_secret:
+            raise ValueError("Missing Spotify credentials in environment")

src/music/fetch.py

@@ -0,0 +1,18 @@
+#TODO:Work on the fetching music from Spotify. Figure out a way to find music based on the emotion detected during the conversation.
+#TODO: Implement a smooth algorithm to sync music without a fail.
+
+
+import json
+import time
+import spotipy
+import random
+from spotipy.oauth2 import SpotifyClientCredentials
+import os
+
+client_id = os.getenv("SPOTIFY_CLIENT_ID")
+client_secret = os.getenv("SPOTIFY_SECRET")
+
+client_credentials_manager = SpotifyClientCredentials(client_id=client_id, client_secret=client_secret)
+
+sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager)
+

src/music/main.py

@@ -0,0 +1,315 @@
+from abc import ABC, abstractmethod
+from spotipy import Spotify
+from spotipy.oauth2 import SpotifyClientCredentials
+from typing import Dict, List, Optional
+import os
+import logging
+from dataclasses import dataclass
+import json
+from datetime import datetime
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# -------------------------
+# Data Structures
+# -------------------------
+
+@dataclass
+class TrackRecommendation:
+    uri: str
+    name: str
+    artist: str
+    preview_url: Optional[str]
+    audio_features: Dict
+
+@dataclass
+class RecommendationParameters:
+    seed_genres: List[str]
+    target_features: Dict
+    limit: int = 20
+    market: str = "US"
+
+# -------------------------
+# Core Interfaces
+# -------------------------
+
+class IMusicRecommendationStrategy(ABC):
+    @abstractmethod
+    def generate_recommendations(self, emotion: str, context: Dict) -> List[TrackRecommendation]:
+        pass
+
+class IAudioAnalyzer(ABC):
+    @abstractmethod
+    def analyze_track(self, track_uri: str) -> Dict:
+        pass
+
+# -------------------------
+# Spotify Client
+# -------------------------
+
+class SpotifyClient:
+    """Handles Spotify authentication and basic API operations"""
+    
+    def __init__(self):
+        self.client_credentials_manager = SpotifyClientCredentials(
+            client_id=os.getenv("SPOTIFY_CLIENT_ID"),
+            client_secret=os.getenv("SPOTIFY_CLIENT_SECRET")
+        )
+        self.client = Spotify(client_credentials_manager=self.client_credentials_manager)
+    
+    def get_recommendations(self, params: RecommendationParameters) -> List[Dict]:
+        """Base recommendation API call"""
+        try:
+            response = self.client.recommendations(
+                seed_genres=params.seed_genres,
+                target_features=params.target_features,
+                limit=params.limit,
+                market=params.market
+            )
+            return response['tracks']
+        except Exception as e:
+            logger.error(f"Recommendation failed: {str(e)}")
+            raise
+
+# -------------------------
+# Emotion Mapping System
+# -------------------------
+
+class EmotionAudioProfile:
+    """Maps emotions to audio characteristics with cultural adaptation"""
+    
+    def __init__(self):
+        self.base_profiles = {
+            "sad": {"target_valence": 0.2, "target_energy": 0.3},
+            "happy": {"target_valence": 0.8, "target_energy": 0.7},
+            "anxious": {"target_valence": 0.5, "target_energy": 0.4},
+            "angry": {"target_valence": 0.3, "target_energy": 0.8}
+        }
+        
+        self.cultural_adjustments = {
+            "US": {"happy": {"target_danceability": 0.8}},
+            "JP": {"happy": {"target_danceability": 0.6}}
+        }
+
+    def get_profile(self, emotion: str, country: str = "US") -> Dict:
+        """Get culturally adjusted audio profile"""
+        profile = self.base_profiles.get(emotion, {}).copy()
+        profile.update(self.cultural_adjustments.get(country, {}).get(emotion, {}))
+        return profile
+
+
+class GenreMapper:
+    """Hierarchical genre mapping system with fallbacks"""
+    
+    def __init__(self, spotify_client: SpotifyClient):
+        self.spotify = spotify_client
+        self.genre_hierarchy = {
+            "sad": ["blues", "soul", "acoustic"],
+            "happy": ["pop", "dance", "disco"],
+            "anxious": ["ambient", "classical"],
+            "angry": ["rock", "metal"]
+        }
+        self.available_genres = self._load_available_genres()
+
+    def _load_available_genres(self) -> List[str]:
+        """Get valid Spotify genres"""
+        return self.spotify.client.recommendation_genre_seeds()['genres']
+
+    def get_genres(self, emotion: str) -> List[str]:
+        """Get best available genres for emotion"""
+        for genre in self.genre_hierarchy.get(emotion, []):
+            if genre in self.available_genres:
+                return [genre]
+        return ["pop"]
+
+# -------------------------
+# AI Integration
+# -------------------------
+
+class LLMEnhancer:
+    """Enhances recommendations using LLM context analysis"""
+    
+    def __init__(self):
+        from langchain_google_genai import ChatGoogleGenerativeAI
+        self.llm = ChatGoogleGenerativeAI(model="gemini-pro")
+
+    def enhance_params(self, context: Dict) -> Dict:
+        """Analyze conversation context for musical attributes"""
+        prompt = f"""
+        Analyze this therapeutic context to suggest music parameters:
+        {json.dumps(context, indent=2)}
+        
+        Return JSON with:
+        - target_energy (0-1)
+        - target_danceability (0-1)
+        - target_tempo 
+        - seed_artist (main artist name)
+        - seed_track (main track name)
+        """
+        
+        try:
+            response = self.llm.invoke(prompt)
+            return json.loads(response.content)
+        except Exception as e:
+            logger.warning(f"LLM enhancement failed: {str(e)}")
+            return {}
+
+# -------------------------
+# Recommendation Engine
+# -------------------------
+
+class TherapeuticMusicRecommender(IMusicRecommendationStrategy):
+    """Main recommendation engine with multiple strategies"""
+    
+    def __init__(self):
+        self.spotify = SpotifyClient()
+        self.audio_profiler = EmotionAudioProfile()
+        self.genre_mapper = GenreMapper(self.spotify)
+        self.llm_enhancer = LLMEnhancer()
+        self.cache = RecommendationCache()
+
+    def generate_recommendations(self, emotion: str, context: Dict) -> List[TrackRecommendation]:
+        """Generate context-aware recommendations"""
+        # Check cache first
+        cache_key = self._generate_cache_key(emotion, context)
+        if cached := self.cache.get(cache_key):
+            return cached
+
+        # Build parameters
+        params = self._build_recommendation_params(emotion, context)
+        
+        # Get raw recommendations
+        raw_tracks = self.spotify.get_recommendations(params)
+        
+        # Process and enrich tracks
+        processed = self._process_tracks(raw_tracks)
+        
+        # Cache results
+        self.cache.store(cache_key, processed)
+        
+        return processed
+
+    def _build_recommendation_params(self, emotion: str, context: Dict) -> RecommendationParameters:
+        """Construct recommendation parameters"""
+        base_features = self.audio_profiler.get_profile(
+            emotion, 
+            context.get('user', {}).get('country', 'US')
+        )
+        
+        llm_features = self.llm_enhancer.enhance_params(context)
+        
+        return RecommendationParameters(
+            seed_genres=self.genre_mapper.get_genres(emotion),
+            target_features={**base_features, **llm_features},
+            market=context.get('user', {}).get('country', 'US'),
+            limit=context.get('limit', 20)
+        )
+
+    def _process_tracks(self, raw_tracks: List[Dict]) -> List[TrackRecommendation]:
+        """Convert raw tracks to enriched recommendations"""
+        return [
+            TrackRecommendation(
+                uri=track['uri'],
+                name=track['name'],
+                artist=track['artists'][0]['name'],
+                preview_url=track.get('preview_url'),
+                audio_features=self.spotify.client.audio_features(track['uri'])[0]
+            ) for track in raw_tracks
+        ]
+
+    def _generate_cache_key(self, emotion: str, context: Dict) -> str:
+        """Generate unique cache key"""
+        return f"{emotion}-{context.get('user', {}).get('id', 'anonymous')}"
+
+# -------------------------
+# Advanced Features
+# -------------------------
+
+class RecommendationCache:
+    """LRU cache for recommendations"""
+    
+    def __init__(self, max_size: int = 100):
+        self.cache = {}
+        self.max_size = max_size
+        self.order = []
+
+    def get(self, key: str) -> Optional[List[TrackRecommendation]]:
+        if key in self.cache:
+            self.order.remove(key)
+            self.order.append(key)
+            return self.cache[key]
+        return None
+
+    def store(self, key: str, recommendations: List[TrackRecommendation]):
+        if len(self.cache) >= self.max_size:
+            oldest = self.order.pop(0)
+            del self.cache[oldest]
+        self.cache[key] = recommendations
+        self.order.append(key)
+
+class MoodTransitionEngine:
+    """Creates playlists that transition between emotional states"""
+    
+    def __init__(self, recommender: TherapeuticMusicRecommender):
+        self.recommender = recommender
+        
+    def create_transition_playlist(self, start_emotion: str, end_emotion: str, context: Dict) -> List[TrackRecommendation]:
+        """Generate mood transition sequence"""
+        steps = self._calculate_transition_steps(start_emotion, end_emotion)
+        playlist = []
+        
+        for step in steps:
+            context['transition_step'] = step
+            playlist += self.recommender.generate_recommendations(
+                emotion=step['emotion'],
+                context=context
+            )
+            
+        return playlist
+
+    def _calculate_transition_steps(self, start: str, end: str) -> List[Dict]:
+        """Determine intermediate emotional states"""
+        transitions = {
+            ('sad', 'happy'): [{'emotion': 'sad', 'intensity': 0.8}, 
+                              {'emotion': 'neutral', 'intensity': 0.5},
+                              {'emotion': 'happy', 'intensity': 0.7}],
+            # Add other transition paths
+        }
+        return transitions.get((start, end), [])
+
+# -------------------------
+# Usage Example
+# -------------------------
+
+if __name__ == "__main__":
+    # Initialize system
+    recommender = TherapeuticMusicRecommender()
+    
+    # Sample context from therapy session
+    context = {
+        "user": {
+            "id": "user123",
+            "country": "US",
+            "time_of_day": datetime.now().hour
+        },
+        "conversation": {
+            "emotion": "anxious",
+            "key_phrases": ["work stress", "sleep issues"],
+            "therapist_notes": "Needs calming music with nature sounds"
+        }
+    }
+    
+    # Generate recommendations
+    recommendations = recommender.generate_recommendations(
+        emotion="anxious",
+        context=context
+    )
+    
+    # Output results
+    print(f"Generated {len(recommendations)} tracks:")
+    for track in recommendations[:3]:
+        print(f"- {track.artist}: {track.name} ({track.audio_features['tempo']} BPM)")

src/music/models/data_models.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+@dataclass
+class TrackRecommendation:
+    uri: str
+    name: str
+    artist: str
+    preview_url: Optional[str]
+    audio_features: Dict
+
+@dataclass
+class RecommendationParameters:
+    seed_genres: List[str]
+    target_features: Dict
+    limit: int = 20
+    market: str = "US"

src/music/services/genre_service.py

@@ -0,0 +1,33 @@
+from typing import Dict, List
+from src.music.clients.spotify_client import SpotifyClient
+from src.music.config.settings import logger, SpotifyConfig
+
+class GenreMapper:
+    """Maps emotions to appropriate genres"""
+    
+    def __init__(self, spotify_client: SpotifyClient):
+        self.spotify = spotify_client
+        self.genre_hierarchy = {
+            "sad": ["blues", "soul", "acoustic"],
+            "happy": ["pop", "dance", "disco"],
+            "anxious": ["ambient", "classical"],
+            "angry": ["rock", "metal"]
+        }
+        self.available_genres = self._load_available_genres()
+
+    def _load_available_genres(self) -> List[str]:
+        """Load available genres from Spotify"""
+        return self.spotify.get_available_genres()
+
+    def get_genres(self, emotion: str) -> List[str]:
+        """Get appropriate genres for an emotion"""
+        emotion_genres = self.genre_hierarchy.get(emotion, [])
+        available = [genre for genre in emotion_genres if genre in self.available_genres]
+        return available if available else ["pop"]
+
+
+
+# Usage:
+client = SpotifyClient(config=SpotifyConfig())
+mapper = GenreMapper(client)
+print(mapper.get_genres("happy"))

src/tele_bot/bot.py

@@ -0,0 +1,100 @@
+#TODO: Collate the necessary features for the Telegram bot, including parts like buttons, other services, Web Search Feature (*Might be nice to try this out.*)
+
+import asyncio
+import logging
+from telegram import Update, ReplyKeyboardMarkup
+from telegram.ext import (
+    Application,
+    CommandHandler,
+    MessageHandler,
+    filters,
+    ContextTypes,
+    CallbackContext
+)
+
+from src.llm.agents.conversation_agent import ConversationAgent
+from src.llm.models.schemas import SessionData
+from src.llm.core.config import settings
+
+# Configure logging
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+conversation_agent = ConversationAgent()
+
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle /start command with interactive keyboard"""
+    keyboard = [
+        ["💬 Start Chatting"],
+        ["ℹ️ About", "🛠 Help"]
+    ]
+    reply_markup = ReplyKeyboardMarkup(keyboard, resize_keyboard=True)
+    
+    welcome_msg = (
+        "🌟 Welcome to Thery AI! 🌟\n\n"
+        "I'm here to provide compassionate mental health support. "
+        "How can I help you today?"
+    )
+    
+    await update.message.reply_text(welcome_msg, reply_markup=reply_markup)
+
+async def handle_message(update: Update, context: CallbackContext):
+    """Process user messages with conversation context"""
+    try:
+        user = update.effective_user
+        text = update.message.text
+        
+        # Get or create session
+        session_data = context.user_data.get('session_data')
+        
+        # Process query
+        response = await conversation_agent.process_async(
+            query=text,
+            session_data=session_data
+        )
+        
+        # Update session data
+        context.user_data['session_data'] = response.session_data
+        
+        # Send response with typing indicator
+        await context.bot.send_chat_action(
+            chat_id=update.effective_chat.id,
+            action="typing"
+        )
+        await update.message.reply_text(response.response)
+
+    except Exception as e:
+        logger.error(f"Error processing message: {str(e)}")
+        await update.message.reply_text("I'm having trouble understanding. Let's try that again.")
+
+
+async def error_handler(update: Update, context: CallbackContext):
+    """Handle errors in the bot"""
+    logger.error(f"Update {update} caused error: {context.error}")
+    await update.message.reply_text("Oops! Something went wrong. Please try again.")
+
+
+def main():
+    """Configure and start the bot"""
+    application = Application.builder().token(settings.TELEGRAM_BOT_TOKEN).build()
+
+    # Add handlers
+    application.add_handler(CommandHandler("start", start))
+    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
+    
+    # Add error handler
+    application.add_error_handler(error_handler)
+
+    # Start polling
+    logger.info("Starting Thery AI Telegram bot...")
+    application.run_polling(
+        poll_interval=1,
+        allowed_updates=Update.ALL_TYPES,
+        drop_pending_updates=True
+    )
+
+if __name__ == "__main__":
+    main()

src/tele_bot/graph.md

@@ -0,0 +1,13 @@
+```mermaid
+    graph TD
+    A[Telegram User] --> B[Telegram Bot]
+    C[Web Frontend] --> D[FastAPI HTTP]
+    C --> E[FastAPI WebSocket]
+    B & D & E --> F[Conversation Agent]
+    F --> G[Emotion Agent]
+    F --> H[Context Agent]
+    G & H --> I[LLM Core]
+    F --> J[Redis Memory]
+    J --> K[Session Management]
+    J --> L[Conversation History]
+```

src/utils/main.py

@@ -0,0 +1,7 @@
+import src.utils.vector_db as vector_db
+import src.utils.pdf_splitter as pdf_splitter
+
+vector_db = vector_db.VectorDatabase("mental_health_db")
+pdf_process = pdf_splitter.PDFProcessor("../data/mental_health")
+processed_pdf = pdf_process.run()
+vector_db.create_db(processed_pdf)

src/utils/pdf_splitter.py

@@ -0,0 +1,37 @@
+import glob
+from langchain_community.document_loaders import PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+class DataExtractor:
+    def __init__(self, pdf_directory):
+        self.pdf_directory = pdf_directory
+        self.pdf_text = []
+        self.docs = []
+        self.split_docs = None
+
+    
+    def extract_text(self):
+        print(f'Extracting text from pdf files in {self.pdf_directory}')
+        pdf_files = glob.glob(f'{self.pdf_directory}/*.pdf')
+        print(pdf_files)
+        for pdf_file in pdf_files:
+            print(pdf_file)
+            loader = PyPDFLoader(pdf_file)
+            documents = loader.load()
+            self.pdf_text.append(documents)
+
+        return self.pdf_text
+
+
+    # Function to clean and split text
+    def clean_and_split_text(self, documents):
+        splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+        split_docs = []
+        print(f'Cleaning and splitting text from {len(documents)} documents')
+        for doc in documents:
+            # Splitting each document individually
+            split_docs.extend(splitter.split_documents(doc))
+        print(f'Number of documents after splitting: {len(split_docs)}')
+        return split_docs
+
+

src/utils/vector_db.py

@@ -0,0 +1,44 @@
+import os
+from src.utils.pdf_splitter import DataExtractor
+from langchain_community.embeddings import HuggingFaceEmbeddings  # Changed
+from langchain_community.vectorstores import FAISS # Fixed import
+
+class VectorDatabase:
+    def __init__(self, db_name):
+        self.db_name = db_name  # Use parameter
+        self.persist_directory = os.path.join("vector_embedding", self.db_name)  # Fixed path
+        
+        # Correct embeddings for sentence-transformers model
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-MiniLM-L6-v2",
+            model_kwargs={"device": "cpu"},
+            encode_kwargs={
+                "padding": "max_length",
+                "max_length": 512,
+                "truncation": True,
+                "normalize_embeddings": True
+            }
+        )
+
+    def create_db(self, pdf_data):
+        # Create and persist database in one step
+        self.vectDB = FAISS.from_documents(
+            documents=pdf_data,
+            embedding=self.embeddings
+        )
+        self.vectDB.save_local(self.persist_directory)
+        # No need for add_documents() or explicit persist() when using from_documents
+
+def main():
+    pdf_directory = './data/mental_health'
+    data_extractor = DataExtractor(pdf_directory)
+    text_data = data_extractor.extract_text()
+    text_data = data_extractor.clean_and_split_text(text_data)
+    
+    # Step 2: Create and load the vector database
+    vector_db = VectorDatabase(db_name="mental_health_vector_db")
+    vector_db.create_db(text_data)
+    print("Vector embeddings have been generated and loaded successfully.")
+
+if __name__ == "__main__":
+    main()