connect to supabase

Dockerfile

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

README.md

@@ -1,14 +1 @@
----
-title: customer_service
-sdk: docker
-emoji: 🚀
-colorFrom: blue
-colorTo: blue
-app_file: app.py
----
 # customer_service
-
-
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

ai_service.py

@@ -0,0 +1,69 @@
+import re
+from config import pc, index, groq_client, EMBED_MODEL, GROQ_MODEL, PROMPT
+from database import db_manager
+
+def clean_ai_response(text: str):
+    cleaned_text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL)
+    return cleaned_text.strip()
+
+async def get_ai_response(user_query: str, telegram_id: int = None):
+    
+    if not pc or not index or not groq_client:
+        return "Ai service is not available at the moment. Please try again later."
+
+    # Save user message if database is available and telegram_id is provided
+    if telegram_id and db_manager:
+        db_manager.save_message(telegram_id, user_query, "user")
+
+    conversation_history = ""
+    if telegram_id and db_manager:
+        conversation_history = db_manager.get_formatted_history(telegram_id, limit=6)
+    
+    
+    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])
+
+    
+    user_content = f"""
+        ### Historical Conversation:
+        {conversation_history}
+
+        ### Retrieved Context from Bank Documents:
+        {retrieved_context}
+
+        ### Current User Message:
+        {user_query}
+
+        بناءً على ما سبق، قدم إجابة دقيقة ومفيدة للعميل:
+        """
+    completion = groq_client.chat.completions.create(
+        messages=[
+            {"role": "system", "content": PROMPT},
+            {"role": "user", "content": f"{conversation_history}\n\nRetrieved Context: {retrieved_context}\n\nCurrent User Message: {user_query}"}
+        ],
+        model=GROQ_MODEL,
+        temperature=0.1,
+        max_completion_tokens=800,
+        top_p=0.9,
+    )
+    ai_response = completion.choices[0].message.content
+    cleaned_response = clean_ai_response(ai_response)
+    
+    # Save assistant response if database is available and telegram_id is provided
+    if telegram_id and db_manager:
+        db_manager.save_message(telegram_id, cleaned_response, "assistant")
+    
+    return cleaned_response
+

app.py

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

@@ -0,0 +1,40 @@
+import os
+from pinecone import Pinecone
+from groq import Groq
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Environment Variables
+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")
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+
+
+# Only create TELEGRAM_URL if token exists
+TELEGRAM_URL = f"https://149.154.167.220/bot{TELEGRAM_TOKEN}/sendMessage" if TELEGRAM_TOKEN else None
+
+EMBED_MODEL = os.environ.get("EMBED_MODEL", "multilingual-e5-large")
+GROQ_MODEL = os.environ.get("GROQ_MODEL", "llama-3.1-8b-instant")
+PROMPT = os.environ.get("PROMPT", "You are a helpful customer service assistant for Hadhramout Bank. Answer the user's question based on the provided context. If the context doesn't contain the answer, politely say you don't have enough information to help with that specific query.")
+
+# Initialize clients only if API keys are available
+pc = None
+if PINECONE_API_KEY:
+    pc = Pinecone(api_key=PINECONE_API_KEY)
+
+groq_client = None
+if GROQ_API_KEY:
+    try:
+        groq_client = Groq(api_key=GROQ_API_KEY)
+    except Exception as e:
+        print(f"Warning: Failed to initialize Groq client: {e}")
+        groq_client = None
+
+# Initialize index only if Pinecone client is available
+index = None
+if pc:
+    index = pc.Index("customerserviceindex")

database.py

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

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

@@ -0,0 +1,25 @@
+from fastapi import FastAPI
+from telegram_handlers import telegram_webhook, test_webhook
+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(request):
+    return await telegram_webhook(request)
+
+@app.post("/test")
+async def test(request):
+    return await test_webhook(request)
+
+@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

@@ -4,3 +4,4 @@ pinecone
 groq
 httpx
 python-dotenv
+supabase

rest.http

@@ -0,0 +1,21 @@
+POST 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

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

@@ -0,0 +1,64 @@
+from fastapi import Request
+import httpx
+from config import TELEGRAM_URL
+from ai_service import get_ai_response
+from database import db_manager
+
+async def telegram_webhook(request: Request):
+    data = await request.json()
+    
+    if "message" in data:
+        telegram_id = data["message"]["chat"]["id"]
+        user_text = data["message"].get("text", "")
+        
+        # Extract user info
+        user_info = data["message"]["chat"]
+        username = user_info.get("username")
+        first_name = user_info.get("first_name")
+        last_name = user_info.get("last_name")
+
+        if user_text:
+            # Save user message to database if available
+            if db_manager:
+                db_manager.save_message(telegram_id, user_text, "user")
+                db_manager.create_or_update_user(telegram_id, username, first_name, last_name)
+            
+            # Get the intelligent response with conversation history
+            ai_answer = await get_ai_response(user_text, telegram_id)
+            
+            # Save assistant response to database if available
+            if db_manager:
+                db_manager.save_message(telegram_id, ai_answer, "assistant")
+            
+            # Send back to Telegram if TELEGRAM_URL is available
+            if TELEGRAM_URL:
+                async with httpx.AsyncClient(verify=False) as client:
+                    await client.post(
+                        TELEGRAM_URL,
+                        headers={"Host": "api.telegram.org"},
+                        json={
+                            "chat_id": telegram_id,
+                            "text": ai_answer,
+                            "parse_mode": "Markdown"
+                        }
+                    )
+                
+    return {"status": "ok"}
+
+async def test_webhook(request: Request):
+    data = await request.json()
+    telegram_id = data["message"]["chat"]["id"]
+    user_text = data["message"]["text"]
+    
+    # Save user message to database if available
+    if db_manager:
+        db_manager.save_message(telegram_id, user_text, "user")
+    
+    # Get response with conversation history
+    response = await get_ai_response(user_text, telegram_id)
+    
+    # Save assistant response to database if available
+    if db_manager:
+        db_manager.save_message(telegram_id, response, "assistant")
+    
+    return {"response": response}

utils.py

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