FEAT: Publishing to HuggingFace from GitHub

Dockerfile

@@ -0,0 +1,37 @@
+# Dockerfile for FastAPI application (with Telegram bot and Redis) deployed on Hugging Face Spaces
+FROM python:3.11-slim
+
+# Install Redis server (requires root privileges)
+USER root
+RUN apt-get update && \
+    apt-get install -y redis-server && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+
+# Create and switch to a non-root user for security
+RUN useradd -m -u 1000 user
+USER user
+
+# Ensure local binaries are in PATH and disable output buffering
+ENV PATH="/home/user/.local/bin:$PATH" \
+    PYTHONUNBUFFERED=1
+
+# Set the working directory
+WORKDIR /app
+
+# Install Python dependencies
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy all application code into the container
+COPY --chown=user . /app
+
+# Copy the entrypoint script into the container and make it executable
+COPY --chown=user entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+# Expose the port used by the FastAPI app (Hugging Face Spaces expects this)
+EXPOSE 7860
+
+# Start everything via the entrypoint script
+CMD ["/app/entrypoint.sh"]

entrypoint.sh

@@ -0,0 +1,13 @@
+set -e
+
+echo "Starting Redis server..."
+# Start Redis in the background
+redis-server &
+
+echo "Starting Telegram bot..."
+# Start the Telegram bot in the background (ensure __main__ in bot.py is set to run the bot)
+python -m src.tele_bot.bot &
+
+echo "Starting FastAPI application..."
+# Start FastAPI with Uvicorn in the foreground so the container keeps running.
+exec uvicorn app.src.api:app --host 0.0.0.0 --port 7860 --workers 1

src/api.py

@@ -9,15 +9,10 @@ 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",
@@ -26,7 +21,6 @@ app = FastAPI(
     redoc_url="/redoc",
     openapi_url="/openapi.json",
     debug=True,
-    on_startup=[on_startup]
 )
 
 
@@ -63,7 +57,7 @@ thread.daemon = True
 thread.start()
 
 
-def run_bot():
+def run_fastapi():
     uvicorn.run(
         "src.api:app",
         host="0.0.0.0",
@@ -71,18 +65,6 @@ def run_bot():
         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()
-    
+if __name__ == "__main__":
+    run_fastapi()

src/llm/agents/context_agent.py

@@ -56,8 +56,36 @@ class ContextAgent(BaseAgent):
             return "Vector search unavailable"
 
 
+    # Updated async web search handling
+    async def _get_web_context_async(self, query: str) -> str:
+        """Async version of web context retrieval"""
+        try:
+            loop = asyncio.get_event_loop()
+            results = await loop.run_in_executor(
+                None,
+                lambda: 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"
+
     async def process_async(self, query: str) -> ContextInfo:
-        return await asyncio.get_event_loop().run_in_executor(
-        None,
-        lambda: self.process(query)
-    )
+        """Async version with parallel context gathering"""
+        web_task = self._get_web_context_async(query)
+        vector_task = asyncio.get_event_loop().run_in_executor(
+            None,
+            lambda: self._get_vector_context(query)
+        )
+        
+        web_context, vector_context = await asyncio.gather(web_task, vector_task)
+        
+        combined_context = f"{web_context}\n\n{vector_context}"
+        
+        self._log_action(action="context_gathered", metadata={"query": query}, level=logging.INFO)
+        return ContextInfo(
+            query=query,
+            web_context=web_context,
+            vector_context=vector_context,
+            combined_context=combined_context,
+        )

src/llm/agents/conversation_agent.py

@@ -186,7 +186,8 @@ class ConversationAgent(BaseAgent):
 
                 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
+                ONLY USE CONTEXT AND EMOTIONAL ANALYSIS IF THEY ALIGN WITH YOUR THOUGHTS ON THE USER'S QUERY, DO NOT REPLY WITH CONTEXT IF THE CONTEXT DOESN'T HELP THE USER.
+                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. 
                 
                 """
 

src/llm/core/config.py

@@ -7,11 +7,11 @@ 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 = ""
+    REDIS_HOST: str = os.getenv("REDIS_HOST")
+    REDIS_PORT: int = os.getenv("REDIS_PORT")
+    # REDIS_DB: int = 0
+    REDIS_USERNAME: str = os.getenv("REDIS_USERNAME")
+    REDIS_PASSWORD: str = os.getenv("REDIS_PASSWORD")
     SESSION_TTL: int = 86400
     MAX_RETRIES: int = 3
     MAX_TOKENS: int = 200

src/llm/memory/redis_connection.py

@@ -17,7 +17,7 @@ class RedisConnection:
         self.redis = redis.Redis(
             host=settings.REDIS_HOST,
             port=settings.REDIS_PORT,
-            db=settings.REDIS_DB,
+            username=settings.REDIS_USERNAME,
             password=settings.REDIS_PASSWORD,
             decode_responses=True
         )

src/llm/routes.py

@@ -1,28 +1,20 @@
-from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
-from fastapi.responses import JSONResponse
+from fastapi import APIRouter, HTTPException, BackgroundTasks
 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
+from src.llm.agents.conversation_agent import ConversationAgent
 
 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"}
-    },
+    tags=["TheryAI Core Services"],
+    responses={500: {"description": "Internal Server Error"}}
 )
 
-# Initialize managers
+# Initialize core components
 session_manager = SessionManager()
 memory_manager = RedisMemoryManager()
 history = RedisHistory()
@@ -31,76 +23,41 @@ conversation_agent = ConversationAgent()
 
 @router.post("/users", response_model=dict)
 async def create_user():
-    """Create a new user and return user_id"""
+    """Create a new 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")
+        logger.error(f"User creation failed: {str(e)}")
+        raise HTTPException(500, "User creation failed")
 
 @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"""
+async def create_session(user_id: str):
+    """Create a new session ID for a user"""
     try:
-        user_id = session_manager.validate_session(session_id)
-        if not user_id:
-            raise HTTPException(status_code=404, detail="Session not found")
-        
+        _, session_id = session_manager.generate_ids(existing_user_id=user_id)
         return SessionData(
             user_id=user_id,
             session_id=session_id,
             is_new_user=False,
-            is_new_session=False
+            is_new_session=True
         )
-    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")
+        logger.error(f"Session creation failed: {str(e)}")
+        raise HTTPException(500, "Session creation failed")
 
 @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"""
+async def get_messages(session_id: str, limit: int = 50):
+    """Get message history for a session"""
     try:
         if not session_manager.validate_session(session_id):
-            raise HTTPException(status_code=404, detail="Session not found")
-        
+            raise HTTPException(404, "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")
+        logger.error(f"Message retrieval failed: {str(e)}")
+        raise HTTPException(500, "Message retrieval failed")
 
 @router.post("/sessions/{session_id}/messages", response_model=ConversationResponse)
 async def create_message(
@@ -108,72 +65,30 @@ async def create_message(
     message: str,
     background_tasks: BackgroundTasks
 ):
-    """Create a new message in a session"""
+    """Process and store a new message"""
     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
-        )
-        
+            raise HTTPException(404, "Invalid session")
+            
         response = await conversation_agent.process_async(
             query=message,
-            session_data=session_data
+            session_data=SessionData(
+                user_id=user_id,
+                session_id=session_id,
+                is_new_user=False,
+                is_new_session=False
+            )
         )
         
-        # Store conversation asynchronously
         background_tasks.add_task(
             memory_manager.store_conversation,
             session_id,
-            str(datetime.now().timestamp()),
+            datetime.now().isoformat(),
             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")
+        logger.error(f"Message processing failed: {str(e)}")
+        raise HTTPException(500, "Message processing failed")

src/main.py

@@ -0,0 +1,14 @@
+from multiprocessing import Process
+from src.api import run_fastapi  # Make sure run_fastapi is importable from src/api.py
+from src.tele_bot.bot import main as run_telegram_bot
+
+if __name__ == "__main__":
+    # Start the Telegram bot in a separate process
+    telegram_process = Process(target=run_telegram_bot)
+    telegram_process.start()
+
+    # Start FastAPI (this will block in the main process)
+    run_fastapi()
+
+    # Optionally, wait for the Telegram process to finish
+    telegram_process.join()

src/tele_bot/bot.py

@@ -47,6 +47,13 @@ async def handle_message(update: Update, context: CallbackContext):
         user = update.effective_user
         text = update.message.text
         
+        typing_task = asyncio.create_task(
+            context.bot.send_chat_action(
+                chat_id=update.effective_chat.id,
+                action="typing"
+            )
+        )
+
         # Get or create session
         session_data = context.user_data.get('session_data')
         
@@ -60,10 +67,7 @@ async def handle_message(update: Update, context: CallbackContext):
         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 typing_task
         await update.message.reply_text(response.response)
 
     except Exception as e: