Update app.py

app.py

@@ -1,68 +1,89 @@
+import gradio as gr
+import os
 import requests
+import uvicorn
+from huggingface_hub import InferenceClient
 from fastapi import FastAPI
 from pydantic import BaseModel
-from huggingface_hub import InferenceClient
-import uvicorn
-import asyncio
-import os
-from dotenv import load_dotenv
-from telegram import Update
-from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext
-
-# Load environment variables
-load_dotenv()
-TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
 
 # Initialize FastAPI
 app = FastAPI()
 
-# Hugging Face Model Client
-client = InferenceClient("RahulGanapathy/MisInfo-ChatBot")
+# Hugging Face Model for Gradio & API
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+
+# Telegram Bot Token (Replace with your actual token)
+TELEGRAM_BOT_TOKEN = "7880465873:AAFDakza41P2drekyUzv-2o8Yp-TBRU7TiU"
+TELEGRAM_API_URL = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
 
-# Request schema for Telegram API
-class RequestData(BaseModel):
+# Define request structure for Telegram API
+class Message(BaseModel):
     text: str
+    chat_id: int
 
-@app.post("/predict")
-async def predict(data: RequestData):
-    """API endpoint for Telegram bot and Gradio UI."""
-    try:
-        response = client.text_generation(prompt=data.text, max_new_tokens=100)
-        return {"response": response}
-    except Exception as e:
-        return {"response": f"Error: {str(e)}"}
+# Function to generate chatbot responses
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    messages = [{"role": "system", "content": system_message}]
 
-# 🚀 Telegram Bot Functions
-async def start(update: Update, context: CallbackContext):
-    """Handles /start command."""
-    await update.message.reply_text("Hello! Send me a message and I'll respond!")
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
 
-async def handle_message(update: Update, context: CallbackContext):
-    """Handles user messages and gets response from Hugging Face API."""
-    user_message = update.message.text
-    response = requests.post("http://0.0.0.0:8000/predict", json={"text": user_message})
+    messages.append({"role": "user", "content": message})
 
-    result = response.json()["response"] if response.status_code == 200 else "Error: Unable to get response from AI."
-    await update.message.reply_text(result)
+    response = ""
 
-async def run_telegram_bot():
-    """Runs the Telegram bot asynchronously."""
-    application = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
-    application.add_handler(CommandHandler("start", start))
-    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
+    for message in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = message.choices[0].delta.content
 
-    # Start polling in the same event loop without trying to close it
-    await application.run_polling()
+        response += token
+        yield response
 
-async def main():
-    """Runs FastAPI and Telegram bot concurrently."""
-    # Start FastAPI
-    config = uvicorn.Config(app, host="0.0.0.0", port=8000)
-    server = uvicorn.Server(config)
+# Gradio UI
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        gr.Textbox(value="You are a helpful Assistant. You let the user to know if the information they share with you is true or false. You return the actual facts behind the information given, after stating the state of Truth or False.", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)",
+        ),
+    ],
+)
+
+# Mount Gradio UI on the root `/`
+app = gr.mount_gradio_app(app, demo, path="/")
+
+@app.post("/predict")
+def predict(data: Message):
+    """Handles Telegram messages and sends a response."""
+    messages = [{"role": "user", "content": data.text}]
+    response = client.chat_completion(messages, max_tokens=512, temperature=0.7)
+    bot_reply = response.choices[0].message.content
 
-    # Run FastAPI & Telegram bot together
-    await asyncio.gather(server.serve(), run_telegram_bot())
+    # Send response back to Telegram user
+    requests.post(TELEGRAM_API_URL, json={"chat_id": data.chat_id, "text": bot_reply})
+    return {"response": bot_reply}
 
-# 🚀 Start both services
 if __name__ == "__main__":
-    asyncio.run(main())
+    uvicorn.run(app, host="0.0.0.0", port=7860)