Upload 11 files

.env

@@ -0,0 +1,10 @@
+GOOGLE_API_KEY=AIzaSyBgqDYEdAQfZuon4zjT1GCmWM8fLTxZyvI
+MONGO_URL=mongodb+srv://sriomdash04:kpDl69XjZunz9PHD@reasoningdata.4sroyx1.mongodb.net/?retryWrites=true&w=majority&appName=ReasoningData
+
+FASTAPI_URL=http://127.0.0.1:8000/generate
+
+LLM_MODEL=gemini-2.5-pro
+
+
+QUESTION_GENERATION_URL = "http://question_service:9000"   
+ANSWER_GENERATION_URL = "http://answer_service:8000"

answer_generation.py

@@ -0,0 +1,167 @@
+import os
+import json
+from dotenv import load_dotenv
+from pydantic import BaseModel
+import google.generativeai as genai
+from fastapi import FastAPI, HTTPException
+import uvicorn
+from prompts import PROMPTS
+from llm_pipeline import example_odia_answer_json, example_odia_question_json
+
+# Setup
+load_dotenv()
+
+# Check for required environment variables
+google_api_key = os.getenv("GOOGLE_API_KEY")
+if not google_api_key:
+    raise ValueError("GOOGLE_API_KEY not found in environment variables")
+
+genai.configure(api_key=google_api_key)
+model = genai.GenerativeModel(os.getenv("LLM_MODEL", "gemini-pro"))
+LANGUAGE = "Odia"
+
+# Models
+class QuestionRequest(BaseModel):
+    question: str
+
+class LLMResponseModel(BaseModel):
+    question_content: str
+    answer_language: str = LANGUAGE
+    reasoning_content: str
+    answer_content: str
+
+def create_prompt(user_odia_question: str) -> str:
+    SIMPLE_PROMPT = PROMPTS["odia_reasoning_generation_prompt"]
+    prompt = SIMPLE_PROMPT.format(
+        user_odia_question=user_odia_question,
+        example_odia_question_json=example_odia_question_json,
+        example_answer_json=example_odia_answer_json
+    )
+
+    return prompt
+# Functions
+def chat_with_model(prompt: str) -> str:
+    try:
+        response = model.generate_content(prompt)
+        return response.text if response.text else "Error: Empty response"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def clean_json_text(text: str) -> str:
+    if text.startswith("Error:"):
+        return text
+    
+    # Remove markdown code blocks
+    text = text.strip()
+    if text.startswith("```"):
+        lines = text.split('\n')
+        if len(lines) > 2:
+            text = '\n'.join(lines[1:-1])
+        else:
+            text = text.strip("`").replace("json", "", 1).strip()
+    
+    # Extract JSON content
+    first = text.find("{")
+    last = text.rfind("}")
+    if first != -1 and last != -1:
+        return text[first:last+1]
+    
+    return text
+
+def validate_output(raw_output: str, original_question: str):
+    cleaned = clean_json_text(raw_output)
+    
+    if cleaned.startswith("Error:"):
+        return {
+            "question_content": original_question,
+            "answer_language": LANGUAGE,
+            "reasoning_content": f"Error occurred: {cleaned}",
+            "answer_content": "Unable to generate answer due to error",
+            "error": cleaned
+        }
+    
+    try:
+        # Try to parse and validate JSON
+        parsed_data = json.loads(cleaned)
+        validated = LLMResponseModel(**parsed_data)
+        return validated.model_dump()
+    except json.JSONDecodeError as je:
+        return {
+            "question_content": original_question,
+            "answer_language": LANGUAGE,
+            "reasoning_content": f"JSON parsing failed: {str(je)}",
+            "answer_content": "Unable to parse model response",
+            "error": f"JSON Error: {str(je)}"
+        }
+    except Exception as e:
+        return {
+            "question_content": original_question,
+            "answer_language": LANGUAGE,
+            "reasoning_content": f"Validation failed: {str(e)}",
+            "answer_content": "Unable to validate model response",
+            "error": f"Validation Error: {str(e)}"
+        }
+
+def run_pipeline(question: str):
+    try:
+        # Use simple prompt if PROMPTS not available
+        prompt =create_prompt(user_odia_question=question)
+        raw_output = chat_with_model(prompt)
+        return validate_output(raw_output, question)
+    except Exception as e:
+        return {
+            "question_content": question,
+            "answer_language": LANGUAGE,
+            "reasoning_content": f"Pipeline error: {str(e)}",
+            "answer_content": "Unable to process question",
+            "error": f"Pipeline Error: {str(e)}"
+        }
+
+# API
+app = FastAPI(title="Odia Question Answering API", version="0.1.0")
+
+@app.get("/")
+async def root():
+    return {"message": "Odia Question Answering API is running", "status": "healthy"}
+
+@app.get("/health")
+async def health_check():
+    try:
+        # Test model connectivity
+        test_response = model.generate_content("Test")
+        return {
+            "status": "healthy",
+            "model": os.getenv("LLM_MODEL", "gemini-pro"),
+            "api_configured": bool(google_api_key)
+        }
+    except Exception as e:
+        return {
+            "status": "unhealthy",
+            "error": str(e),
+            "api_configured": bool(google_api_key)
+        }
+
+@app.post("/generate")
+async def generate_answer(request: QuestionRequest):
+    try:
+        if not request.question.strip():
+            raise HTTPException(status_code=400, detail="Question cannot be empty")
+        
+        result = run_pipeline(request.question.strip())
+        
+        # Check for critical errors that should return 500
+        if "error" in result and any(err_type in result["error"] for err_type in ["Error: ", "Pipeline Error:"]):
+            raise HTTPException(status_code=500, detail=f"Processing failed: {result['error']}")
+        
+        return {"success": True, "data": result}
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+
+if __name__ == "__main__":
+    print("Starting Odia Question Answering API...")
+    print(f"Google API Key configured: {'Yes' if google_api_key else 'No'}")
+    print(f"Model: {os.getenv('LLM_MODEL', 'gemini-pro')}")
+    uvicorn.run(app, host="127.0.0.1", port=9000, reload=True)

app.py

@@ -0,0 +1,177 @@
+import gradio as gr
+from controller import generate_questions       # returns question_list (or a dict containing it)
+from controller import generate_answer         # returns a dict with question_content, answer_content, reasoning_content
+from db import save_in_db                      # saves parsed dict into mongo
+
+MAX_QUESTIONS = 20
+
+# ---------------- Helpers ---------------- #
+def _extract_question_list(result):
+    """Safely extract question list from a controller response"""
+    if not result:
+        return []
+    if isinstance(result, dict):
+        if "success" in result and isinstance(result.get("data"), dict):
+            return result["data"].get("question_list", [])
+        if "question_list" in result:
+            return result["question_list"] or []
+        if "data" in result and isinstance(result["data"], list):
+            return result["data"]
+    if isinstance(result, list):
+        return result
+    return []
+
+def _extract_qa(result, original_q):
+    """Return a dict with question_content, answer_content, reasoning_content"""
+    default = {
+        "question_content": original_q,
+        "answer_content": "No answer returned",
+        "reasoning_content": ""
+    }
+    if not result:
+        return default
+    if isinstance(result, dict):
+        d = result.get("data") if result.get("success") and isinstance(result.get("data"), dict) else result
+        return {
+            "question_content": d.get("question_content", original_q),
+            "answer_content": d.get("answer_content", d.get("answer", "")) or "",
+            "reasoning_content": d.get("reasoning_content", d.get("reasoning", "")) or ""
+        }
+    return default
+
+# ---------------- Handlers ---------------- #
+def generate_questions_ui(topic: str, num_questions: int):
+    """Stream Q → A → R one by one"""
+    result_values = []
+    for _ in range(MAX_QUESTIONS):
+        result_values.extend([
+            "", "", "",  # Q, A, R
+            gr.update(visible=False, interactive=False),  # accept
+            gr.update(visible=False, interactive=False),  # reject
+            gr.update(visible=False)  # group hidden
+        ])
+    yield result_values
+
+    try:
+        qres = generate_questions(topic.strip(), int(num_questions))
+    except Exception as e:
+        result_values[0] = f"Error generating questions: {e}"
+        yield result_values
+        return
+
+    question_list = _extract_question_list(qres)
+    if not question_list:
+        result_values[0] = "No questions returned."
+        yield result_values
+        return
+
+    for i, q in enumerate(question_list[:MAX_QUESTIONS]):
+        base = i * 6
+        result_values[base + 0] = q
+        result_values[base + 1] = "Generating answer..."
+        result_values[base + 2] = "Generating reasoning..."
+        result_values[base + 5] = gr.update(visible=True)
+        yield result_values
+
+        try:
+            ans_res = generate_answer(q)
+            qa = _extract_qa(ans_res, q)
+            result_values[base + 1] = qa["answer_content"]
+            result_values[base + 2] = qa["reasoning_content"]
+            result_values[base + 3] = gr.update(visible=True, interactive=True)
+            result_values[base + 4] = gr.update(visible=True, interactive=True)
+        except Exception as e:
+            result_values[base + 1] = f"Error: {e}"
+            result_values[base + 2] = ""
+            result_values[base + 4] = gr.update(visible=True, interactive=True)
+
+        yield result_values
+
+    yield result_values
+
+def accept_question(question, answer, reasoning):
+    """Save in DB and hide card"""
+    parsed = {
+        "question_content": question,
+        "answer_language": "Odia",
+        "reasoning_content": reasoning,
+        "answer_content": answer,
+    }
+    try:
+        save_in_db(parsed)
+        return (
+            gr.update(visible=False),  # accept_btn
+            gr.update(visible=False),  # reject_btn
+            gr.update(visible=False)   # group hidden
+        )
+    except Exception as e:
+        return (
+            gr.update(interactive=False, value=f"Error: {e}"),
+            gr.update(visible=True),
+            gr.update(visible=True)
+        )
+
+def reject_card():
+    """Hide rejected card"""
+    return gr.update(visible=False)
+
+# ---------------- UI Layout ---------------- #
+custom_css = """
+.gradio-container { background-color: #121212 !important; color: #E0E0E0 !important; }
+.question-card { 
+    border: 1px solid #333; 
+    box-shadow: 0 4px 12px rgba(0,0,0,0.4); 
+    border-radius: 12px; 
+    padding: 20px !important; 
+    margin-bottom: 20px !important; 
+    background-color: #1E1E1E; 
+    transition: 0.3s ease-in-out; 
+}
+.question-card:hover { 
+    transform: translateY(-3px); 
+    box-shadow: 0 6px 16px rgba(0,0,0,0.6); 
+}
+textarea { background-color: #2A2A2A !important; color: #E0E0E0 !important; border: 1px solid #444 !important; border-radius: 8px !important; }
+button { border-radius: 8px !important; padding: 8px 12px !important; }
+"""
+
+with gr.Blocks(theme=gr.themes.Base(), css=custom_css) as demo:
+    gr.Markdown("<h2 style='color:#90CAF9;'>🌙 Odia Q&A — Generate → Answer (streaming)</h2>")
+
+    with gr.Row():
+        topic_input = gr.Textbox(label="📝 Topic", placeholder="Enter a topic, e.g., 'Photosynthesis'")
+        num_questions_input = gr.Dropdown(label="🔢 Number of Questions", choices=[5, 10, 15, 20], value=5)
+        generate_btn = gr.Button("⚡ Generate", variant="primary")
+
+    output_components = []
+    for i in range(MAX_QUESTIONS):
+        with gr.Group(visible=False, elem_classes=["question-card"]) as output_group:
+            with gr.Row():
+                with gr.Column(scale=4):
+                    q_text = gr.Textbox(label="❓ Question", interactive=False)
+                    a_text = gr.Textbox(label="✅ Answer", interactive=False)
+                    r_text = gr.Textbox(label="🧠 Reasoning", interactive=False)
+                with gr.Column(scale=1, min_width=150):
+                    accept_btn = gr.Button("Accept", variant="primary")
+                    reject_btn = gr.Button("Reject", variant="stop")
+
+            # Bind buttons
+            accept_btn.click(
+                fn=accept_question,
+                inputs=[q_text, a_text, r_text],  # ✅ only inputs
+                outputs=[accept_btn, reject_btn, output_group]  # ✅ update group visibility
+            )
+            reject_btn.click(fn=reject_card, outputs=[output_group])
+
+            output_components.extend([q_text, a_text, r_text, accept_btn, reject_btn, output_group])
+
+    generate_btn.click(
+        fn=generate_questions_ui,
+        inputs=[topic_input, num_questions_input],
+        outputs=output_components
+    )
+
+    demo.queue()
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

compose.yaml

@@ -0,0 +1,48 @@
+# This file is for local development.
+# It uses "build: ." to create an image from your local source code.
+
+services:
+  # Service 1: The Answer Generation FastAPI app
+  answer_service:
+    build: .
+    container_name: answer_service
+    command: ["uvicorn", "answer_generation:app", "--host", "0.0.0.0", "--port", "8000"]
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    volumes:
+      - .:/app
+    environment:
+      - PYTHONPATH=/app
+
+  # Service 2: The Question Generation FastAPI app
+  question_service:
+    build: .
+    container_name: question_service
+    command: ["uvicorn", "question_generation:app", "--host", "0.0.0.0", "--port", "9000"]
+    ports:
+      - "9000:9000"
+    env_file:
+      - .env
+    volumes:
+      - .:/app
+    environment:
+      - PYTHONPATH=/app
+
+  # Service 3: The Gradio UI app
+  gradio_app:
+    build: .
+    container_name: gradio_app
+    command: ["python", "app.py"]
+    ports:
+      - "7860:7860"
+    env_file:
+      - .env
+    volumes:
+      - .:/app
+    depends_on:
+      - answer_service
+      - question_service
+    environment:
+      - PYTHONPATH=/app

controller.py

@@ -0,0 +1,30 @@
+import requests
+import os 
+
+
+QUESTION_GENERATION_URL = "http://127.0.0.1:8000"   
+ANSWER_GENERATION_URL = "http://127.0.0.1:9000"
+
+def generate_questions(topic: str, num_questions: int = 10):
+    url = f"{QUESTION_GENERATION_URL}/generate-questions"
+    payload = {
+        "topic": topic,
+        "num_questions": num_questions
+    }
+    try:
+        response = requests.post(url, json=payload)
+        response.raise_for_status()  # Raise error if status != 200
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        return {"error": str(e)}
+      
+def generate_answer(question: str):
+    url = f"{ANSWER_GENERATION_URL}/generate"
+    payload = {"question": question}
+
+    try:
+        response = requests.post(url, json=payload)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        return {"error": str(e)}

db.py

@@ -0,0 +1,80 @@
+from pymongo.mongo_client import MongoClient
+from pymongo.server_api import ServerApi
+import datetime
+import os
+import uuid
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+uri = os.getenv("MONGO_URL")
+
+# ✅ Create Mongo client
+client = MongoClient(uri, server_api=ServerApi('1'))
+
+# ✅ Ping test
+try:
+    client.admin.command('ping')
+    print("✅ Connected to MongoDB!")
+except Exception as e:
+    print("❌ MongoDB connection failed:", e)
+
+# ✅ Database & Collection
+db = client["ReasoningData"]
+collection = db["formatted_data"]
+
+# ✅ Global trackers
+global_question_list = []
+counter = 0
+
+
+def generate_unique_id():
+    """
+    Generates a unique ID for each question.
+    Example: ODR_20250822_123456_uuid
+    """
+    global counter
+    prefix = "ODR"
+    timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+    unique_id = f"{prefix}_{timestamp}_{counter:05d}"
+    counter = (counter + 1) % 100000
+    return unique_id
+
+
+def convert_into_mongo_document(parsed_json):
+    """
+    Converts parsed Pydantic object (or dict) into Mongo document.
+    """
+    if hasattr(parsed_json, "dict"):  # if it's a Pydantic model
+        parsed_json = parsed_json.dict()
+
+    data = {
+        "question_id": generate_unique_id(),
+        "question_content": parsed_json.get("question_content"),
+        "answer_language": parsed_json.get("answer_language"),
+        "reasoning_content": parsed_json.get("reasoning_content"),
+        "answer_content": parsed_json.get("answer_content"),
+    }
+    return data
+
+
+def insert_into_mongo(data):
+    """
+    Inserts a document into MongoDB.
+    """
+    try:
+        data["_id"] = data["question_id"]
+        result = collection.insert_one(data)
+        global_question_list.append(result.inserted_id)
+        print("✅ Inserted document ID:", result.inserted_id)
+    except Exception as e:
+        print("❌ Error inserting document:", e)
+
+
+def save_in_db(parsed_json):
+    """
+    Full pipeline: convert → insert.
+    """
+    data = convert_into_mongo_document(parsed_json)
+    insert_into_mongo(data)
+

dockerfile

@@ -0,0 +1,15 @@
+
+FROM python:3.10-slim
+
+WORKDIR /app
+
+
+COPY requirements.txt .
+
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+
+COPY . .
+
+

llm_pipeline.py

@@ -0,0 +1,13 @@
+example_odia_question_json = {
+    "question_content": "ଏକ ଦୃଷ୍ଟାନ୍ତ ପ୍ରଶ୍ନ",
+    "answer_language": "Odia",
+    "reasoning_content": "ଏଠାରେ ସଠିକ୍ ତରୀକାରେ ଧାରଣା ବିବେଚନା କରନ୍ତୁ",
+    "answer_content": "ଫଳାଫଳ"
+}
+
+example_odia_answer_json = {
+    "question_content": "ଏକ ଦୃଷ୍ଟାନ୍ତ ପ୍ରଶ୍ନ",
+    "answer_language": "Odia",
+    "reasoning_content": "ଏଠାରେ ଧାରଣା ବିବେଚନା",
+    "answer_content": "ଫଳାଫଳ"
+}

prompts.py

@@ -0,0 +1,79 @@
+# prompts.py
+
+PROMPTS = {
+    "questions_only": """
+You are a meticulous question-setter who writes clear, solvable, but advance level reasoning-based mathematics questions in {language}.
+The topic is: "{topic}".
+
+The question should be of advanced level and should be of under graduate standard level, and should include multiple subtopics of the main topic to solve the question.
+
+The question should be of 10 marks and at least take 10 minutes duration to solve.
+
+It should force the user to think and solve the question by multiple steps.
+
+The question should be conclusive , it should not have multiple final answers , although the approach might be multiple.
+
+### Requirements:
+- Generate exactly {num_questions} unique questions (±1 if absolutely necessary).
+- Language: {language} only (do not use English unless part of notation like symbols, variables, or numbers).
+- Each question must be reasoning-based and solvable with pen-and-paper.
+- Do NOT provide answers, solutions, hints, or commentary.
+- Keep the questions self-contained and unambiguous.
+- Use realistic and moderate numbers (avoid very large, complex, or impractical values).
+- Ensure variety: mix easy, medium, and at most 2 hard-level questions.
+- Stay strictly within the topic.
+
+### Output Format:
+Return ONLY valid JSON, following this schema exactly:
+
+{{
+  "question_language": "{language}",
+  "question_list": [
+    "<Q1 in {language}>",
+    "<Q2 in {language}>",
+    "<Q3 in {language}>",
+    ...
+  ]
+}}
+
+### Rules:
+- Output must be valid JSON (no markdown formatting, no ``` fences).
+- Do NOT include extra keys or metadata.
+- Do NOT repeat questions.
+- Ensure the length of "question_list" is approximately {num_questions}.
+    """,
+
+    "odia_reasoning_generation_prompt": """
+You are an intelligent Odia language reasoning teacher, highly experienced in teaching mental reasoning questions. 
+You are known for always giving correct answers and explaining the step-by-step reasoning clearly in Odia. 
+You will be provided with a query in JSON format like this: {example_odia_question_json} (use this only as an example).
+
+⚠️ IMPORTANT RULES:
+- Output must be ONLY valid JSON (no markdown, no text outside JSON).
+- Use the exact keys: question_content, answer_language, reasoning_content, answer_content.
+- The key "answer_content" MUST contain the final concise answer in Odia; do NOT leave it empty.
+- All fields must be filled.
+- Always answer in Odia language.
+- Do not invent new keys, do not add comments.
+- reasoning_content must show proper step-by-step process, leading from the question to the final answer.
+
+The JSON structure you must return is:
+{{
+  "question_content": "string (the question in Odia)",
+  "answer_language": "Odia",
+  "reasoning_content": "string (detailed reasoning in Odia, step by step)",
+  "answer_content": "string (final concise answer in Odia)"
+}}
+
+Use this answer as an example: {example_answer_json}
+
+Now, process the following query (already wrapped in JSON) and return the result strictly in the required JSON structure:
+
+{{
+  "question_content": "{user_odia_question}",
+  "answer_language": "Odia",
+  "reasoning_content": "",
+  "answer_content": ""
+}}
+"""
+}

question_generation.py

@@ -0,0 +1,98 @@
+import os
+import json
+from dotenv import load_dotenv
+from pydantic import BaseModel, ValidationError
+from typing import List
+from prompts import PROMPTS
+import google.generativeai as genai
+from fastapi import FastAPI, HTTPException
+import uvicorn
+
+# Setup
+load_dotenv()
+google_api_key = os.getenv("GOOGLE_API_KEY")
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+model = genai.GenerativeModel(os.getenv("LLM_MODEL", "gemini-pro"))
+
+# Models
+class TopicRequest(BaseModel):
+    topic: str
+    num_questions: int = 10
+
+class GeneratedQuestionModel(BaseModel):
+    question_language: str
+    question_list: List[str]
+
+# Functions
+def chat_with_model(prompt: str) -> str:
+    try:
+        response = model.generate_content(prompt)
+        return response.text if response.text else "Error: Empty response"
+    except Exception as e:
+        return f"Error: {e}"
+
+def clean_json_text(text: str) -> str:
+    if text.startswith("Error:"):
+        return text
+    if text.startswith("```"):
+        lines = text.split('\n')
+        text = '\n'.join(lines[1:-1]) if len(lines) > 2 else text.strip("`").replace("json", "", 1).strip()
+    first, last = text.find("{"), text.rfind("}")
+    return text[first:last+1] if first != -1 and last != -1 else text
+
+def validate_answer(raw_output: str):
+    cleaned = clean_json_text(raw_output)
+    if cleaned.startswith("Error:"):
+        return {"error": cleaned, "question_language": "Odia", "question_list": []}
+    try:
+        return GeneratedQuestionModel.model_validate_json(cleaned).model_dump()
+    except ValidationError:
+        try:
+            return GeneratedQuestionModel(**json.loads(cleaned)).model_dump()
+        except:
+            return {"error": "Invalid JSON", "question_language": "Odia", "question_list": []}
+
+def final_pipeline(user_input: str, num_questions: int = 10):
+    prompt = PROMPTS["questions_only"].format(language="Odia", topic=user_input, num_questions=num_questions)
+    return validate_answer(chat_with_model(prompt))
+
+# API
+app = FastAPI()
+
+@app.get("/health")
+async def health_check():
+    try:
+        # Test model connectivity
+        test_response = model.generate_content("Test")
+        return {
+            "status": "healthy",
+            "model": os.getenv("LLM_MODEL", "gemini-pro"),
+            "api_configured": bool(google_api_key)
+        }
+    except Exception as e:
+        return {
+            "status": "unhealthy",
+            "error": str(e),
+            "api_configured": bool(google_api_key)
+        }
+@app.get("/")
+async def root():
+    return {"message": "Odia Question Generating API is running", "status": "healthy"}
+
+
+@app.post("/generate-questions")
+async def generate_questions(request: TopicRequest):
+    if not request.topic.strip():
+        raise HTTPException(status_code=400, detail="Topic cannot be empty")
+    if not 1 <= request.num_questions <= 50:
+        raise HTTPException(status_code=400, detail="Questions must be between 1-50")
+    
+    result = final_pipeline(request.topic.strip(), request.num_questions)
+    
+    if "error" in result and "Error:" in result["error"]:
+        raise HTTPException(status_code=500, detail=result["error"])
+    
+    return {"success": True, "data": result}
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)

requirements.txt

@@ -0,0 +1,21 @@
+# FastAPI and Server
+fastapi==0.115.9
+uvicorn==0.31.0
+
+# Google Generative AI
+google-generativeai==0.8.5
+
+# Gradio UI
+gradio==5.31.0
+
+# Database
+pymongo==4.11.3
+
+# Data Validation
+pydantic==2.11.5
+
+# HTTP Requests
+requests==2.32.3
+
+# Environment Variables
+python-dotenv==1.0.1