hadramout bank

.gitignore

@@ -1,7 +0,0 @@
-.env
-__pycache__/
-*.pyc
-.venv/
-venv/
-.python-version
-.DS_Store

Dockerfile

@@ -4,17 +4,14 @@ FROM python:3.11-slim
 # Set working directory
 WORKDIR /app
 
-# Set environment variables for Hugging Face Spaces (can be overridden for local development)
+# Set environment variables
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
-    PORT=7860 \
-    HF_HOME=/app/cache \
-    TRANSFORMERS_CACHE=/app/cache
+    PORT=7860
 
-# Install system dependencies including curl for health check
+# Install system dependencies
 RUN apt-get update && apt-get install -y \
     gcc \
-    curl \
     && rm -rf /var/lib/apt/lists/*
 
 # Copy requirements first for better caching
@@ -24,18 +21,20 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir -r requirements.txt
 
-# Copy all application code
-COPY . .
+# Copy application code
+COPY app.py .
 
-# Create cache directory for Hugging Face models
-RUN mkdir -p /app/cache && chmod 777 /app/cache
+# Create non-root user for security
+RUN useradd --create-home --shell /bin/bash app && \
+    chown -R app:app /app
+USER app
 
-# Expose port (default 8000 for local, can be set to 7860 for Hugging Face Spaces)
-EXPOSE ${PORT}
+# Expose port
+EXPOSE 7860
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:${PORT}/ || exit 1
+    CMD curl -f http://localhost:7860/ || exit 1
 
-# Run the application (uses PORT environment variable)
-CMD sh -c "uvicorn main:app --host 0.0.0.0 --port ${PORT}"
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,36 +1,14 @@
 ---
-title: Customer Service AI
-emoji: 🤖
-colorFrom: blue
-colorTo: purple
+title: customer_service
 sdk: docker
-sdk_version: "latest"
-app_file: main.py
-pinned: false
+emoji: 🚀
+colorFrom: blue
+colorTo: blue
+app_file: app.py
 ---
+# customer_service
 
-# Customer Service AI Backend
-
-FastAPI backend for Hadhramout Bank AI customer service system.
 
-## Features
-- Telegram webhook integration
-- AI-powered responses using Hugging Face Inference API
-- Database integration with Supabase
-- Vector search with Pinecone
-
-## API Endpoints
-- `GET /` - Health check
-- `POST /webhook` - Telegram webhook endpoint
-- `POST /test` - Test webhook functionality
-- `GET /dns-test` - DNS connectivity test
-- `GET /ai-test` - AI response test
-
-## Deployment
-This application is deployed on Hugging Face Spaces using Docker.
+---
 
-## Local Development
-```bash
-docker build -t customer-service .
-docker run -p 8000:8000 customer-service
-```
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

ai_service.py

@@ -1,110 +0,0 @@
-import re
-import json
-import os
-from config import pc, index, EMBED_MODEL, hf_client, PROMPT, HF_MODEL
-from database import db_manager
-
-
-MODEL_NAME = HF_MODEL
-
-def clean_ai_response(text: str):
-    if not text: return ""
-    text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL)
-    text = re.sub(r'<br\s*/?>', '\n', text)
-    text = re.sub(r'<[^>]+>', '', text)
-    text = re.sub(r'^\|.*\|\s*$', '', text, flags=re.MULTILINE)
-    text = re.sub(r'^[\s|:-]+$', '', text, flags=re.MULTILINE)
-    text = re.sub(r'^#{1,6}\s*', '', text, flags=re.MULTILINE)
-    text = re.sub(r'\n{3,}', '\n\n', text)
-    return text.strip()
-
-async def search_bank_knowledge(query: str):
-    query_embedding = pc.inference.embed(
-        model=EMBED_MODEL,
-        inputs=[query],
-        parameters={"input_type": "query"}
-    )
-    
-    search_results = index.query(
-        vector=query_embedding[0].values,
-        top_k=3,
-        include_metadata=True
-    )
-    
-    return "\n".join([res.metadata['original_text'] for res in search_results.matches])
-
-TOOLS = [
-    {
-        "type": "function",
-        "function": {
-            "name": "search_bank_knowledge",
-            "description": "Use this tool to search the official Hadhramout Bank profile for accurate information about services, organizational structure, capital, and policies.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "query": {
-                        "type": "string",
-                        "description": "The search query (e.g., 'What is Hadhramout Bank capital?' or 'individual services')."
-                    }
-                },
-                "required": ["query"]
-            }
-        }
-    }
-]
-
-async def get_ai_response(user_query: str, telegram_id: int):
-    conversation_history = []
-    if db_manager:
-        raw_history = db_manager.get_conversation_history(telegram_id, limit=6)
-        raw_history.reverse()
-        for msg in raw_history:
-            if msg.get('message_text'):
-                role = "user" if msg['message_type'] == 'user' else "assistant"
-                conversation_history.append({"role": role, "content": msg['message_text']})
-
-    messages = [{"role": "system", "content": PROMPT}] + conversation_history + [{"role": "user", "content": user_query}]
-    
-    
-    import asyncio
-    loop = asyncio.get_event_loop()
-    
-    
-    def call_hf(msgs):
-        return hf_client.chat.completions.create(
-            model=MODEL_NAME,
-            messages=msgs,
-            tools=TOOLS,
-            tool_choice="auto",
-            temperature=0.1,
-            max_tokens=800
-        )
-
-    completion = await loop.run_in_executor(None, lambda: call_hf(messages))
-    response_message = completion.choices[0].message
-
-    # Handle tool call if model requests it
-    if response_message.tool_calls:
-        tool_call = response_message.tool_calls[0]
-        args = json.loads(tool_call.function.arguments)
-        tool_result = await search_bank_knowledge(args["query"])
-
-        messages.append(response_message)
-        messages.append({
-            "role": "tool",
-            "tool_call_id": tool_call.id,
-            "content": tool_result
-        })
-
-        completion = await loop.run_in_executor(None, lambda: call_hf(messages))
-        response_message = completion.choices[0].message
-
-    final_response = clean_ai_response(response_message.content if response_message.content else "")
-    print(f"--- AI Raw Response: {repr(response_message.content)} ---")
-    print(f"--- AI Final Response: {repr(final_response)} ---")
-
-    if db_manager:
-        db_manager.save_message(telegram_id, user_query, "user")
-        db_manager.save_message(telegram_id, final_response, "assistant")
-
-    return final_response

app.py

@@ -0,0 +1,113 @@
+import os
+from fastapi import FastAPI, Request
+from pinecone import Pinecone
+from groq import Groq
+import httpx 
+import re
+
+# 1. Configuration & Clients
+# Use Hugging Face Secrets for these!
+PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+TELEGRAM_TOKEN = os.environ.get("TELEGRAM_TOKEN")
+TELEGRAM_URL = f"https://149.154.167.220/bot{TELEGRAM_TOKEN}/sendMessage"
+
+EMBED_MODEL= os.environ.get("EMBED_MODEL")
+GROQ_MODEL = os.environ.get("GROQ_MODEL")
+PROMPT = os.environ.get("PROMPT")
+
+pc = Pinecone(api_key=PINECONE_API_KEY)
+index = pc.Index("customerserviceindex")
+groq_client = Groq(api_key=GROQ_API_KEY)
+
+app = FastAPI()
+
+def clean_ai_response(text: str):
+    # إزالة كل ما بين وسمي <think> و </think> بما في ذلك الوسوم نفسها
+    cleaned_text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL)
+    return cleaned_text.strip()
+
+# 2. The Core AI Logic
+async def get_ai_response(user_query: str):
+    # Vectorize query using Pinecone Inference
+    query_embedding = pc.inference.embed(
+        model=EMBED_MODEL,
+        inputs=[user_query],
+        parameters={"input_type": "query"}
+    )
+
+    # Search Pinecone for Bank Context
+    search_results = index.query(
+        vector=query_embedding[0].values,
+        top_k=3,
+        include_metadata=True
+    )
+    
+    retrieved_context = "\n".join([res.metadata['original_text'] for res in search_results.matches])
+
+    
+    prompt = f"""
+    {PROMPT}
+    
+    Message:{user_query}
+    
+    Retrieved Context:{retrieved_context}
+    
+    Final Answer:
+    """
+
+    completion = groq_client.chat.completions.create(
+        messages=[{"role": "user", "content": prompt}],
+        model=GROQ_MODEL,
+        temperature=0.1,
+        max_completion_tokens=800,
+        top_p=0.9,
+    )
+    ai_response = completion.choices[0].message.content
+    return clean_ai_response(ai_response)
+
+# 3. The Webhook Endpoint
+@app.post("/webhook")
+async def telegram_webhook(request: Request):
+    data = await request.json()
+    
+    if "message" in data:
+        chat_id = data["message"]["chat"]["id"]
+        user_text = data["message"].get("text", "")
+
+        if user_text:
+            # Get the intelligent response
+            ai_answer = await get_ai_response(user_text)
+            # Send back to Telegram
+            async with httpx.AsyncClient(verify=False) as client:
+                await client.post(
+                    TELEGRAM_URL,
+                    headers={"Host": "api.telegram.org"},
+                    json={
+                        "chat_id": chat_id,
+                        "text": ai_answer,
+                        "parse_mode": "Markdown"
+                    }
+                )
+                
+    return {"status": "ok"}
+
+@app.get("/")
+async def root():
+    return {"message": "Hadhramout Bank AI Backend is Live"}
+
+@app.post("/test")
+async def test_webhook(request: Request):
+    data = await request.json()
+    response = await get_ai_response(data["message"]["text"])
+    return {"response": response}
+
+import socket
+
+@app.get("/dns-test")
+async def dns_test():
+    try:
+        ip = socket.gethostbyname("api.telegram.org")
+        return {"resolved_ip": ip}
+    except Exception as e:
+        return {"error": str(e)}

config.py

@@ -1,46 +0,0 @@
-import os
-from pinecone import Pinecone
-from openai import OpenAI
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
-
-# Environment Variables
-PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
-HF_TOKEN = os.environ.get("HF_TOKEN") or os.environ.get("HF_API_KEY")
-TELEGRAM_TOKEN = os.environ.get("TELEGRAM_TOKEN")
-SUPABASE_URL = os.environ.get("SUPABASE_URL")
-SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
-TELEGRAM_DOMAIN = os.environ.get("TELEGRAM_DOMAIN", "https://api.telegram.org").rstrip("/")
-
-# Only create TELEGRAM_URL if token exists
-TELEGRAM_URL = f"{TELEGRAM_DOMAIN}/bot{TELEGRAM_TOKEN}/sendMessage" if TELEGRAM_TOKEN and TELEGRAM_DOMAIN else None
-
-EMBED_MODEL = os.environ.get("EMBED_MODEL", "multilingual-e5-large")
-HF_MODEL = os.environ.get(
-    "HF_MODEL",
-    "dphn/Dolphin-Mistral-24B-Venice-Edition",
-)
-PROMPT = os.environ.get("PROMPT")
-
-# Initialize clients only if API keys are available
-pc = None
-if PINECONE_API_KEY:
-    pc = Pinecone(api_key=PINECONE_API_KEY)
-
-hf_client = None
-if HF_TOKEN:
-    try:
-        hf_client = OpenAI(
-            base_url="https://router.huggingface.co/v1",
-            api_key=HF_TOKEN,
-        )
-    except Exception as e:
-        print(f"Warning: Failed to initialize Hugging Face OpenAI client: {e}")
-        hf_client = None
-
-# Initialize index only if Pinecone client is available
-index = None
-if pc:
-    index = pc.Index("customerserviceindex")

database.py

@@ -1,202 +0,0 @@
-import os
-from datetime import datetime
-from typing import List, Dict, Optional
-from supabase import create_client, Client
-import logging
-from config import SUPABASE_URL, SUPABASE_KEY
-
-
-class DatabaseManager:
-    def __init__(self, supabase_url: str = SUPABASE_URL, supabase_key: str = SUPABASE_KEY):
-        if not supabase_url or not supabase_key:
-            raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables")
-        
-        self.supabase: Client = create_client(supabase_url, supabase_key)
-        self.logger = logging.getLogger(__name__)
-    
-    def create_or_update_user(self, telegram_id: int, username: str = None, 
-                            first_name: str = None, last_name: str = None):
-        """Create or update user information"""
-        try:
-            # Check if user exists
-            existing_user = self.supabase.table("users").select("id").eq("telegram_id", telegram_id).execute()
-            
-            user_data = {
-                "telegram_id": telegram_id,
-                "username": username,
-                "first_name": first_name,
-                "last_name": last_name,
-                "updated_at": datetime.utcnow().isoformat()
-            }
-            
-            if existing_user.data:
-                # Update existing user
-                result = self.supabase.table("users").update(user_data).eq("telegram_id", telegram_id).execute()
-            else:
-                # Create new user
-                user_data["created_at"] = datetime.utcnow().isoformat()
-                result = self.supabase.table("users").insert(user_data).execute()
-            
-            return result.data[0] if result.data else None
-            
-        except Exception as e:
-            self.logger.error(f"Error creating/updating user: {e}")
-            return None
-    
-    def save_message(self, telegram_id: int, message_text: str, message_type: str):
-        """Save a message to the database"""
-        try:
-            # Ensure user exists
-            self.create_or_update_user(telegram_id)
-            
-            # Save message
-            message_data = {
-                "telegram_id": telegram_id,
-                "message_text": message_text,
-                "message_type": message_type,
-                "created_at": datetime.utcnow().isoformat()
-            }
-            
-            result = self.supabase.table("messages").insert(message_data).execute()
-            
-            # Ensure active session exists
-            self._ensure_active_session(telegram_id)
-            
-            return result.data[0] if result.data else None
-            
-        except Exception as e:
-            self.logger.error(f"Error saving message: {e}")
-            return None
-    
-    def get_conversation_history(self, telegram_id: int, limit: int = 10) -> List[Dict]:
-        """Get conversation history for a user"""
-        try:
-            result = (self.supabase.table("messages")
-                     .select("message_text, message_type, created_at")
-                     .eq("telegram_id", telegram_id)
-                     .order("created_at", desc=True)
-                     .limit(limit)
-                     .execute())
-            
-            return result.data if result.data else []
-            
-        except Exception as e:
-            self.logger.error(f"Error getting conversation history: {e}")
-            return []
-    
-    def get_formatted_history(self, telegram_id: int, limit: int = 10) -> str:
-        """Get formatted conversation history for Groq"""
-        history = self.get_conversation_history(telegram_id, limit)
-        
-        if not history:
-            return ""
-        
-        # Reverse to get chronological order
-        history.reverse()
-        
-        formatted_history = "Previous conversation:\n"
-        for msg in history:
-            role = "User" if msg['message_type'] == 'user' else "Assistant"
-            formatted_history += f"{role}: {msg['message_text']}\n"
-        
-        return formatted_history
-    
-    def _ensure_active_session(self, telegram_id: int):
-        """Ensure an active session exists for the user"""
-        try:
-            # Check for active session
-            active_session = (self.supabase.table("conversation_sessions")
-                             .select("id")
-                             .eq("telegram_id", telegram_id)
-                             .is_("session_end", "null")
-                             .execute())
-            
-            if not active_session.data:
-                # Create new session
-                session_data = {
-                    "telegram_id": telegram_id,
-                    "session_start": datetime.utcnow().isoformat(),
-                    "created_at": datetime.utcnow().isoformat()
-                }
-                self.supabase.table("conversation_sessions").insert(session_data).execute()
-                
-        except Exception as e:
-            self.logger.error(f"Error ensuring active session: {e}")
-    
-    def start_new_session(self, telegram_id: int):
-        """Start a new conversation session"""
-        try:
-            # End previous sessions
-            self.supabase.table("conversation_sessions").update({
-                "session_end": datetime.utcnow().isoformat()
-            }).eq("telegram_id", telegram_id).is_("session_end", "null").execute()
-            
-            # Start new session
-            session_data = {
-                "telegram_id": telegram_id,
-                "session_start": datetime.utcnow().isoformat(),
-                "created_at": datetime.utcnow().isoformat()
-            }
-            result = self.supabase.table("conversation_sessions").insert(session_data).execute()
-            
-            return result.data[0] if result.data else None
-            
-        except Exception as e:
-            self.logger.error(f"Error starting new session: {e}")
-            return None
-    
-    def get_user_stats(self, telegram_id: int) -> Dict:
-        """Get user conversation statistics"""
-        try:
-            # Get message counts
-            message_stats = (self.supabase.table("messages")
-                           .select("message_type")
-                           .eq("telegram_id", telegram_id)
-                           .execute())
-            
-            if not message_stats.data:
-                return {
-                    "total_messages": 0,
-                    "user_messages": 0,
-                    "assistant_messages": 0,
-                    "first_message": None,
-                    "last_message": None
-                }
-            
-            total_messages = len(message_stats.data)
-            user_messages = len([m for m in message_stats.data if m['message_type'] == 'user'])
-            assistant_messages = len([m for m in message_stats.data if m['message_type'] == 'assistant'])
-            
-            # Get first and last message timestamps
-            timestamps = [m['created_at'] for m in message_stats.data]
-            first_message = min(timestamps) if timestamps else None
-            last_message = max(timestamps) if timestamps else None
-            
-            return {
-                "total_messages": total_messages,
-                "user_messages": user_messages,
-                "assistant_messages": assistant_messages,
-                "first_message": first_message,
-                "last_message": last_message
-            }
-            
-        except Exception as e:
-            self.logger.error(f"Error getting user stats: {e}")
-            return {
-                "total_messages": 0,
-                "user_messages": 0,
-                "assistant_messages": 0,
-                "first_message": None,
-                "last_message": None
-            }
-
-# Global database instance
-try:
-    db_manager = DatabaseManager()
-except ValueError as e:
-    print(f"Database initialization failed: {e}")
-    print("Please set SUPABASE_URL and SUPABASE_KEY environment variables")
-    db_manager = None
-except Exception as e:
-    print(f"Unexpected database error: {e}")
-    db_manager = None

database_schema.sql

@@ -1,56 +0,0 @@
--- Conversation History Database Schema
--- SQLite Database Structure
-
--- Users table to store user information
-CREATE TABLE IF NOT EXISTS users (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    chat_id BIGINT UNIQUE NOT NULL,
-    username VARCHAR(255),
-    first_name VARCHAR(255),
-    last_name VARCHAR(255),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- Messages table to store conversation history
-CREATE TABLE IF NOT EXISTS messages (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    chat_id BIGINT NOT NULL,
-    message_text TEXT NOT NULL,
-    message_type VARCHAR(20) NOT NULL CHECK (message_type IN ('user', 'assistant')),
-    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY (chat_id) REFERENCES users(chat_id) ON DELETE CASCADE
-);
-
--- Conversation sessions to group messages by session
-CREATE TABLE IF NOT EXISTS conversation_sessions (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    chat_id BIGINT NOT NULL,
-    session_start TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    session_end TIMESTAMP NULL,
-    message_count INTEGER DEFAULT 0,
-    FOREIGN KEY (chat_id) REFERENCES users(chat_id) ON DELETE CASCADE
-);
-
--- Indexes for better performance
-CREATE INDEX IF NOT EXISTS idx_messages_chat_id_timestamp ON messages(chat_id, timestamp);
-CREATE INDEX IF NOT EXISTS idx_users_chat_id ON users(chat_id);
-CREATE INDEX IF NOT EXISTS idx_sessions_chat_id ON conversation_sessions(chat_id);
-
--- Trigger to update user's updated_at timestamp
-CREATE TRIGGER IF NOT EXISTS update_user_timestamp 
-    AFTER INSERT ON messages
-    FOR EACH ROW
-    BEGIN
-        UPDATE users SET updated_at = CURRENT_TIMESTAMP WHERE chat_id = NEW.chat_id;
-    END;
-
--- Trigger to update session message count
-CREATE TRIGGER IF NOT EXISTS update_session_count
-    AFTER INSERT ON messages
-    FOR EACH ROW
-    BEGIN
-        UPDATE conversation_sessions 
-        SET message_count = message_count + 1 
-        WHERE chat_id = NEW.chat_id AND session_end IS NULL;
-    END;

main.py

@@ -1,25 +0,0 @@
-from fastapi import FastAPI
-from telegram_handlers import telegram_webhook, WebhookData
-from utils import dns_test, test_ai_response
-
-app = FastAPI()
-
-@app.get("/")
-async def root():
-    return {"message": "Hadhramout Bank AI Backend is Live"}
-
-@app.post("/webhook")
-async def webhook(data: WebhookData):
-    return await telegram_webhook(data)
-
-# @app.post("/test")
-# async def test(data: WebhookData):
-#     return await test_webhook(data)
-
-@app.get("/dns-test")
-async def dns():
-    return await dns_test()
-
-@app.get("/ai-test")
-async def ai():
-    return await test_ai_response()

requirements.txt

@@ -1,7 +1,6 @@
 fastapi
 uvicorn
 pinecone
+groq
 httpx
 python-dotenv
-supabase
-openai

rest.http

@@ -1,21 +0,0 @@
-GET https://codeboker-customer-service.hf.space/ai-test HTTP/1.1
-Content-Type: application/json
-
-{
-    "message": {
-        "chat": {"id": 123},
-        "text": "هاي"
-    }
-}
-###
-GET https://codeboker-customer-service.hf.space/ai-test HTTP/1.1
-
-###
-POST https://codeboker-customer-service.hf.space/webhook HTTP/1.1
-Content-Type: application/json
-{
-    "message": {
-        "chat": {"id": 123},
-        "text": "السلام عليكم وؤحمة الله اريد ان استعلم عنلاالخدمات الالكترونية"
-    }
-}

supabase_schema.sql

@@ -1,90 +0,0 @@
--- Supabase Database Schema for Conversation History
--- Run this in your Supabase SQL Editor
-
--- Enable UUID extension
-CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-
--- Users table to store user information
-CREATE TABLE IF NOT EXISTS users (
-    id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
-    telegram_id BIGINT UNIQUE NOT NULL,
-    username VARCHAR(255),
-    first_name VARCHAR(255),
-    last_name VARCHAR(255),
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-);
-
--- Messages table to store conversation history
-CREATE TABLE IF NOT EXISTS messages (
-    id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
-    telegram_id BIGINT NOT NULL,
-    message_text TEXT NOT NULL,
-    message_type VARCHAR(20) NOT NULL CHECK (message_type IN ('user', 'assistant')),
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    FOREIGN KEY (telegram_id) REFERENCES users(telegram_id) ON DELETE CASCADE
-);
-
--- Conversation sessions to group messages by session
-CREATE TABLE IF NOT EXISTS conversation_sessions (
-    id UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
-    telegram_id BIGINT NOT NULL,
-    session_start TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    session_end TIMESTAMP WITH TIME ZONE,
-    message_count INTEGER DEFAULT 0,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    FOREIGN KEY (telegram_id) REFERENCES users(telegram_id) ON DELETE CASCADE
-);
-
--- Indexes for better performance
-CREATE INDEX IF NOT EXISTS idx_messages_telegram_id_created_at ON messages(telegram_id, created_at);
-CREATE INDEX IF NOT EXISTS idx_users_telegram_id ON users(telegram_id);
-CREATE INDEX IF NOT EXISTS idx_sessions_telegram_id ON conversation_sessions(telegram_id);
-
--- Function to update updated_at timestamp
-CREATE OR REPLACE FUNCTION update_updated_at_column()
-RETURNS TRIGGER AS $$
-BEGIN
-    NEW.updated_at = NOW();
-    RETURN NEW;
-END;
-$$ language 'plpgsql';
-
--- Trigger to update user's updated_at timestamp
-CREATE TRIGGER update_user_updated_at 
-    BEFORE UPDATE ON users
-    FOR EACH ROW
-    EXECUTE FUNCTION update_updated_at_column();
-
--- Trigger to update session message count
-CREATE OR REPLACE FUNCTION update_session_count()
-RETURNS TRIGGER AS $$
-BEGIN
-    UPDATE conversation_sessions 
-    SET message_count = message_count + 1 
-    WHERE telegram_id = NEW.telegram_id AND session_end IS NULL;
-    RETURN NEW;
-END;
-$$ language 'plpgsql';
-
-CREATE TRIGGER update_session_message_count
-    AFTER INSERT ON messages
-    FOR EACH ROW
-    EXECUTE FUNCTION update_session_count();
-
--- Row Level Security (RLS) policies
-ALTER TABLE users ENABLE ROW LEVEL SECURITY;
-ALTER TABLE messages ENABLE ROW LEVEL SECURITY;
-ALTER TABLE conversation_sessions ENABLE ROW LEVEL SECURITY;
-
--- Policy for users table (allow all operations for now)
-CREATE POLICY "Enable all operations for users" ON users
-    FOR ALL USING (true);
-
--- Policy for messages table (allow all operations for now)
-CREATE POLICY "Enable all operations for messages" ON messages
-    FOR ALL USING (true);
-
--- Policy for conversation_sessions table (allow all operations for now)
-CREATE POLICY "Enable all operations for conversation_sessions" ON conversation_sessions
-    FOR ALL USING (true);

telegram_handlers.py

@@ -1,149 +0,0 @@
-from pydantic import BaseModel
-import httpx
-import json
-from config import TELEGRAM_URL
-from ai_service import get_ai_response
-from database import db_manager
-
-TELEGRAM_IP = "149.154.167.220"
-MAX_TELEGRAM_MESSAGE_LENGTH = 4096
-
-
-def _sanitize_telegram_text(text: str) -> str:
-    if text is None:
-        return ""
-
-    normalized = str(text).replace("\r\n", "\n").replace("\r", "\n")
-
-    # Remove control/surrogate chars that Telegram can reject.
-    cleaned = "".join(
-        ch
-        for ch in normalized
-        if (ch in ("\n", "\t") or ord(ch) >= 32) and not (0xD800 <= ord(ch) <= 0xDFFF)
-    )
-    return cleaned.strip()
-
-
-def _split_telegram_message(text: str, max_length: int = MAX_TELEGRAM_MESSAGE_LENGTH):
-    if len(text) <= max_length:
-        return [text]
-
-    parts = []
-    remaining = text
-
-    while len(remaining) > max_length:
-        split_at = remaining.rfind("\n", 0, max_length)
-        if split_at == -1:
-            split_at = remaining.rfind(" ", 0, max_length)
-        if split_at == -1:
-            split_at = max_length
-
-        part = remaining[:split_at].strip()
-        if not part:
-            part = remaining[:max_length]
-            split_at = max_length
-
-        parts.append(part)
-        remaining = remaining[split_at:].strip()
-
-    if remaining:
-        parts.append(remaining)
-
-    return parts
-
-class ChatInfo(BaseModel):
-    id: int
-    username: str = None
-    first_name: str = None
-    last_name: str = None
-
-class Message(BaseModel):
-    chat: ChatInfo
-    text: str = ""
-
-class WebhookData(BaseModel):
-    message: Message = None
-
-async def telegram_webhook(data: WebhookData):
-    try:
-        if not data.message or not data.message.text:
-            return {"status": "ok"}
-
-        telegram_id = data.message.chat.id
-        user_text = data.message.text
-        
-        username = data.message.chat.username
-        first_name = data.message.chat.first_name
-
-        print(f"--- Processing message from {first_name} ---")
-
-        if db_manager:
-            db_manager.create_or_update_user(telegram_id, username, first_name, data.message.chat.last_name)
-
-        
-        ai_answer = await get_ai_response(user_text, telegram_id)
-        
-
-        
-        if TELEGRAM_URL:
-            try:
-                from config import TELEGRAM_TOKEN 
-                
-                async with httpx.AsyncClient(timeout=40.0, verify=False, follow_redirects=True) as client:
-                    prepared_text = _sanitize_telegram_text(
-                        ai_answer or "Sorry, I couldn't generate a response. Please try again."
-                    )
-                    if not prepared_text:
-                        prepared_text = "Sorry, I couldn't generate a response. Please try again."
-
-                    message_parts = _split_telegram_message(prepared_text, MAX_TELEGRAM_MESSAGE_LENGTH)
-
-                    for idx, part in enumerate(message_parts, start=1):
-                        payload = {
-                            "chat_id": telegram_id,
-                            "text": part,
-                        }
-
-                        print(
-                            f"--- Sending Telegram message part {idx}/{len(message_parts)} "
-                            f"(chars={len(part)}) ---"
-                        )
-
-                        try:
-                            # Use form data for maximal compatibility with Telegram endpoint parsers.
-                            response = await client.post(TELEGRAM_URL, data=payload)
-                        except Exception:
-                            print(f"--- DNS Failed. Forcing Direct IP Routing to {TELEGRAM_IP} ---")
-
-                            forced_ip_url = f"https://{TELEGRAM_IP}/bot{TELEGRAM_TOKEN}/sendMessage"
-                            json_body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-                            headers = {
-                                "Host": "api.telegram.org",
-                                "Content-Type": "application/json; charset=utf-8",
-                                "Content-Length": str(len(json_body)),
-                            }
-
-                            response = await client.post(
-                                forced_ip_url,
-                                content=json_body,
-                                headers=headers,
-                            )
-
-                        if response.status_code != 200:
-                            print(f"--- Telegram payload rejected (part {idx}) ---")
-                            print(f"--- Payload: {payload} ---")
-                            print(
-                                f"--- Telegram Rejected Request: "
-                                f"{response.status_code} - {response.text} ---"
-                            )
-                            break
-                    else:
-                        print("--- Success: All Telegram message parts delivered ---")
-                        
-            except Exception as send_error:
-                print(f"--- Emergency: Network Blockage Detected: {str(send_error)} ---")
-                    
-        return {"status": "ok"}
-    except Exception as e:
-        print(f"Error in webhook: {str(e)}")
-        return {"status": "error", "message": str(e)}

utils.py

@@ -1,16 +0,0 @@
-import socket
-
-async def dns_test():
-    try:
-        ip = socket.gethostbyname("api.telegram.org")
-        return {"resolved_ip": ip}
-    except Exception as e:
-        return {"error": str(e)}
-
-async def test_ai_response():
-    try:
-        from ai_service import get_ai_response
-        response = await get_ai_response("عن ماذا كنت اسال", 12)
-        return {"response": response}
-    except Exception as e:
-        return {"error": str(e)}