Spaces:

FredyHoundayi
/

JANGG_AI_API

Sleeping

App Files Files Community

prbranch

by FredyHoundayi - opened Feb 1

base: refs/heads/main

←

from: refs/pr/2

Discussion Files changed

+202

-589

This PR is in draft mode

Files changed (13) hide show

.env.example +9 -0
.gitignore +70 -14
README.md +6 -39
app/main.py +91 -0
app/prompts/complete_course_prompt.py +0 -47
app/routers/integrated.py +0 -130
app/routers/video.py +0 -72
app/schemas/complete_course.py +0 -25
app/schemas/video.py +0 -22
app/services/learning_agent.py +1 -70
app/services/video_service.py +0 -123
main.py +2 -31
requirements.txt +23 -16

.env.example ADDED Viewed

	@@ -0,0 +1,9 @@

+# API Keys
+GROQ_API_KEY=your_groq_api_key_here
+OPENAI_API_KEY=your_openai_api_key_here
+# Database
+DATABASE_URL=sqlite:///./brain_platform.db
+# Other settings
+ENVIRONMENT=production

.gitignore CHANGED Viewed

@@ -1,19 +1,75 @@
 __pycache__/
-.venv/
-venv/
-env/
-.env
-*.pyc
-*.pyo
-*.pyd
 .Python
-.mypy_cache/
 .pytest_cache/
 *.mp3
-*.mp4
 *.wav
-*.jpg
-*.png
-*.gif
-*.log

+# Python
 __pycache__/
+*.py[cod]
+*$py.class
+*.so
 .Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+demo-env/
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+# Logs
+*.log
+logs/
+# Database
+*.db
+*.sqlite3
+# Jupyter Notebook
+.ipynb_checkpoints
+# pytest
+.coverage
 .pytest_cache/
+htmlcov/
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+# Audio files
+app/static/audio/
 *.mp3
 *.wav
+*.ogg

README.md CHANGED Viewed

@@ -1,44 +1,11 @@
 ---
 title: JANGG AI API
-emoji: 🤖
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 6.5.1
-python_version: '3.10'
-app_file: main.py
 pinned: false
 ---
-# JANGG AI API
-API complète pour la génération de contenu éducatif avec IA
-## Fonctionnalités
-- Génération de cours personnalisés
-- Création de quiz interactifs
-- Synthèse vocale (TTS)
-- Génération de vidéos éducatives
-## Configuration requise
-- Python 3.10+
-- Voir [requirements.txt](cci:7://file:///home/fredy/T%C3%A9l%C3%A9chargements/JANG%20API/Jangg-/requirements.txt:0:0-0:0) pour les dépendances
-## Installation locale
-```bash
-# Cloner le dépôt
-git clone [https://huggingface.co/spaces/FredyHoundayi/JANGG_AI_API](https://huggingface.co/spaces/FredyHoundayi/JANGG_AI_API)
-cd JANGG_AI_API
-# Créer un environnement virtuel
-python -m venv venv
-source venv/bin/activate  # Sur Windows: venv\Scripts\activate
-# Installer les dépendances
-pip install -r requirements.txt
-# Lancer l'API
-uvicorn main:app --reload

 ---
 title: JANGG AI API
+emoji: 🌖
+colorFrom: indigo
+colorTo: pink
+sdk: docker
 pinned: false
+short_description: demo friday 30/01/2026
 ---
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/main.py ADDED Viewed

	@@ -0,0 +1,91 @@

+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+from app.routers import chat, quiz, audio
+app = FastAPI(title="JANGG AI API", description="Intelligent API for interactive learning with AI")
+app.mount("/static", StaticFiles(directory="app/static"), name="static")
+app.include_router(chat.router)
+app.include_router(quiz.router)
+app.include_router(audio.router)
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    html_content = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>JANGG AI API</title>
+        <style>
+            body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+            .header { text-align: center; color: #2c3e50; margin-bottom: 30px; }
+            .endpoint { background: #f8f9fa; padding: 15px; margin: 10px 0; border-radius: 5px; border-left: 4px solid #3498db; }
+            .method { color: #27ae60; font-weight: bold; }
+            .path { color: #2980b9; font-family: monospace; }
+            .description { color: #34495e; margin-top: 5px; }
+            .docs-link { background: #3498db; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px; display: inline-block; margin-top: 20px; }
+        </style>
+    </head>
+    <body>
+        <div class="header">
+            <h1>🤖 JANGG AI API</h1>
+            <p>Intelligent API for interactive learning with AI</p>
+        </div>
+        <h2>📚 Available Endpoints</h2>
+        <div class="endpoint">
+            <span class="method">GET</span> <span class="path">/</span>
+            <div class="description">API home page</div>
+        </div>
+        <div class="endpoint">
+            <span class="method">GET</span> <span class="path">/health</span>
+            <div class="description">API health check</div>
+        </div>
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/chat/</span>
+            <div class="description">AI chat interface for interactive conversations</div>
+        </div>
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/quiz/generate</span>
+            <div class="description">Generate personalized quizzes based on a topic</div>
+        </div>
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/quiz/validate</span>
+            <div class="description">Validate quiz answers</div>
+        </div>
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/audio/text-to-speech</span>
+            <div class="description">Convert text to speech</div>
+        </div>
+        <div class="endpoint">
+            <span class="method">POST</span> <span class="path">/audio/speech-to-text</span>
+            <div class="description">Convert speech to text</div>
+        </div>
+        <div style="text-align: center; margin-top: 30px;">
+            <a href="/docs" class="docs-link">📖 Interactive Documentation (Swagger)</a>
+            <br><br>
+            <a href="/redoc" class="docs-link">📋 Alternative Documentation (ReDoc)</a>
+        </div>
+        <div style="text-align: center; margin-top: 30px; color: #7f8c8d;">
+            <p>© 2026 JANGG AI API - Intelligent Learning Platform</p>
+        </div>
+    </body>
+    </html>
+    """
+    return HTMLResponse(content=html_content)
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "api": "JANGG AI API", "version": "1.0.0"}

app/prompts/complete_course_prompt.py DELETED Viewed

@@ -1,47 +0,0 @@
-COMPLETE_COURSE_TEMPLATE = """
-You are a friendly AI tutor and content creator.
-Generate a complete learning package about {topic} for the {sector} sector.
-Parameters:
-- Tone: {tone}
-- Style: {style}
-- Length: {length}
-- Language: French
-Requirements:
-1. Generate engaging course content
-2. Create relevant quiz questions
-3. Structure content for video generation with scenes
-Format your response as JSON:
-{{
-  "course": "Complete course content with clear sections and examples",
-  "quiz": [
-    {{
-      "question": "Clear question about the content",
-      "options": ["Option A", "Option B", "Option C", "Option D"],
-      "answer": 2
-    }}
-  ],
-  "video_scenes": [
-    {{
-      "title": "Scene title",
-      "content": "Narration text for this scene (2-3 sentences)",
-      "duration": 8,
-      "visual_prompt": "Visual description for AI image generation"
-    }}
-  ]
-}}
-Rules:
-- Course: Clear, structured, beginner-friendly with practical examples
-- Quiz: 5 questions testing key concepts
-- Video Scenes: 5-8 scenes covering the main topics
-- Each scene content should be speakable (natural for text-to-speech)
-- Visual prompts should be descriptive for image generation
-- Duration per scene: 5-12 seconds based on content length
-Return only valid JSON.
-"""

app/routers/integrated.py DELETED Viewed

@@ -1,130 +0,0 @@
-from fastapi import APIRouter, HTTPException
-from app.schemas.chat import LearnRequest
-from app.schemas.complete_course import CompleteCourseResponse, VideoFromScenesRequest
-from app.services.learning_agent import generate_complete_learning_package
-from app.services.video_service import video_service
-import time
-router = APIRouter(prefix="/integrated", tags=["Integrated Learning"])
-@router.post("/complete-course", response_model=CompleteCourseResponse)
-def generate_complete_learning_experience(req: LearnRequest):
-    """
-    Generate a complete learning package in a single LLM inference.
-    This endpoint generates:
-    1. Course content
-    2. Quiz questions
-    3. Video-ready scenes with visual prompts
-    All content is generated coherently in one LLM call for better consistency.
-    """
-    try:
-        start_time = time.time()
-        # Generate everything in one inference
-        complete_data = generate_complete_learning_package(req.dict())
-        processing_time = time.time() - start_time
-        return CompleteCourseResponse(
-            course=complete_data["course"],
-            quiz=complete_data["quiz"],
-            video_scenes=complete_data["video_scenes"],
-            message="Complete learning package generated successfully",
-            generation_method="unified_llm"
-        )
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Complete course generation failed: {str(e)}"
-        )
-@router.post("/video-from-scenes")
-def generate_video_from_scenes(req: VideoFromScenesRequest):
-    """
-    Generate video from pre-generated scenes.
-    Use this with scenes from /integrated/complete-course for optimal results.
-    """
-    try:
-        start_time = time.time()
-        # Convert scenes to video service format
-        video_data = {
-            "topic": req.topic,
-            "style": req.style,
-            "tone": req.tone,
-            "language": req.language,
-            "scenes": [
-                {
-                    "title": scene.title,
-                    "content": scene.content,
-                    "duration": scene.duration
-                }
-                for scene in req.scenes
-            ]
-        }
-        video_path = video_service.generate_course_video(video_data)
-        processing_time = time.time() - start_time
-        return {
-            "video_path": video_path,
-            "scenes_used": len(req.scenes),
-            "processing_time": processing_time,
-            "message": "Video generated from scenes successfully"
-        }
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Video from scenes generation failed: {str(e)}"
-        )
-@router.post("/full-pipeline")
-def generate_full_learning_pipeline(req: LearnRequest):
-    """
-    Complete pipeline: generate content AND create video in one call.
-    This combines content generation and video creation for maximum convenience.
-    """
-    try:
-        start_time = time.time()
-        # Step 1: Generate complete content package
-        complete_data = generate_complete_learning_package(req.dict())
-        # Step 2: Generate video from the scenes
-        video_data = {
-            "topic": req.topic,
-            "style": req.style,
-            "tone": req.tone,
-            "language": "fr",
-            "scenes": complete_data["video_scenes"]
-        }
-        video_path = video_service.generate_course_video(video_data)
-        total_time = time.time() - start_time
-        return {
-            "course": complete_data["course"],
-            "quiz": complete_data["quiz"],
-            "video_scenes": complete_data["video_scenes"],
-            "video_path": video_path,
-            "total_processing_time": total_time,
-            "generation_method": "unified_llm_plus_video",
-            "message": "Full learning pipeline completed successfully"
-        }
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Full pipeline generation failed: {str(e)}"
-        )

app/routers/video.py DELETED Viewed

@@ -1,72 +0,0 @@
-import time
-from fastapi import APIRouter, HTTPException
-from app.schemas.video import VideoRequest, VideoResponse
-from app.services.video_service import video_service
-router = APIRouter(prefix="/video", tags=["Video"])
-@router.post("/generate", response_model=VideoResponse)
-def generate_course_video(request: VideoRequest):
-    """
-    Generate a course video based on the provided scenes and settings.
-    This endpoint creates a video by:
-    1. Generating images for each scene using Stable Diffusion
-    2. Converting text to speech using gTTS
-    3. Creating video segments with FFmpeg
-    4. Concatenating all segments into a final video
-    """
-    try:
-        start_time = time.time()
-        # Convert request to dict for service
-        course_data = {
-            "topic": request.topic,
-            "style": request.style,
-            "tone": request.tone,
-            "language": request.language,
-            "scenes": [
-                {
-                    "title": scene.title,
-                    "content": scene.content,
-                    "duration": scene.duration
-                }
-                for scene in request.scenes
-            ]
-        }
-        # Generate video
-        video_path = video_service.generate_course_video(course_data)
-        processing_time = time.time() - start_time
-        return VideoResponse(
-            video_path=video_path,
-            message="Video generated successfully",
-            processing_time=processing_time
-        )
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Video generation failed: {str(e)}"
-        )
-@router.get("/health")
-def video_health_check():
-    """Check if video generation service is available"""
-    try:
-        # Check if the model is loaded
-        model_loaded = video_service.pipe is not None
-        return {
-            "status": "healthy" if model_loaded else "degraded",
-            "model_loaded": model_loaded,
-            "service": "video_generation"
-        }
-    except Exception as e:
-        raise HTTPException(
-            status_code=503,
-            detail=f"Video service unavailable: {str(e)}"
-        )

app/schemas/complete_course.py DELETED Viewed

@@ -1,25 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import List, Dict
-class VideoScene(BaseModel):
-    title: str = Field(..., description="Title of the video scene")
-    content: str = Field(..., description="Narration text for the scene")
-    duration: int = Field(..., description="Duration in seconds")
-    visual_prompt: str = Field(..., description="Visual description for AI image generation")
-class CompleteCourseResponse(BaseModel):
-    course: str = Field(..., description="Complete course content")
-    quiz: List[Dict] = Field(..., description="Quiz questions with options and answers")
-    video_scenes: List[VideoScene] = Field(..., description="Scenes ready for video generation")
-    message: str = Field(default="Complete learning package generated successfully")
-    generation_method: str = Field(default="unified", description="How the content was generated")
-class VideoFromScenesRequest(BaseModel):
-    topic: str = Field(..., description="Topic of the course")
-    style: str = Field(default="cartoon", description="Visual style")
-    tone: str = Field(default="educational", description="Content tone")
-    language: str = Field(default="fr", description="Language for audio")
-    scenes: List[VideoScene] = Field(..., description="Pre-generated scenes")

app/schemas/video.py DELETED Viewed

@@ -1,22 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import List, Optional
-class Scene(BaseModel):
-    title: str = Field(..., description="Title of the scene")
-    content: str = Field(..., description="Content/narration for the scene")
-    duration: int = Field(..., description="Duration in seconds")
-class VideoRequest(BaseModel):
-    topic: str = Field(..., description="Topic of the course")
-    style: str = Field(default="cartoon", description="Visual style for video generation")
-    tone: str = Field(default="fun", description="Tone of the content")
-    language: str = Field(default="fr", description="Language for audio generation")
-    scenes: List[Scene] = Field(..., description="List of scenes for the video")
-class VideoResponse(BaseModel):
-    video_path: str = Field(..., description="Path to the generated video file")
-    message: str = Field(..., description="Status message")
-    processing_time: Optional[float] = Field(None, description="Total processing time in seconds")

app/services/learning_agent.py CHANGED Viewed

@@ -2,13 +2,12 @@ from langchain_core.prompts import PromptTemplate
 from app.core.llm import llm
 from app.prompts.course_prompt import COURSE_TEMPLATE
 from app.prompts.quiz_prompt import QUIZ_TEMPLATE
-from app.prompts.complete_course_prompt import COMPLETE_COURSE_TEMPLATE
 import json
 import re
 def generate_course_and_quiz(params):
-    """Legacy function - generates course and quiz separately"""
     course_prompt = PromptTemplate.from_template(COURSE_TEMPLATE)
     course = llm.invoke(
@@ -37,71 +36,3 @@ def generate_course_and_quiz(params):
         ]
     return course, quiz
-def generate_complete_learning_package(params):
-    """
-    Generate course, quiz, and video-ready scenes in a single LLM inference.
-    Returns:
-        dict: {
-            "course": str,
-            "quiz": list,
-            "video_scenes": list
-        }
-    """
-    complete_prompt = PromptTemplate.from_template(COMPLETE_COURSE_TEMPLATE)
-    response = llm.invoke(
-        complete_prompt.format(**params)
-    ).content
-    # Extract JSON from response
-    json_match = re.search(r'\{.*\}', response, re.DOTALL)
-    if json_match:
-        try:
-            complete_data = json.loads(json_match.group(0))
-            # Validate structure
-            required_keys = ["course", "quiz", "video_scenes"]
-            if all(key in complete_data for key in required_keys):
-                return complete_data
-            else:
-                raise ValueError("Missing required keys in LLM response")
-        except json.JSONDecodeError as e:
-            print(f"JSON parsing error: {e}")
-            return _fallback_generation(params)
-    else:
-        print("No JSON found in LLM response")
-        return _fallback_generation(params)
-def _fallback_generation(params):
-    """Fallback to separate generation if unified approach fails"""
-    print("Falling back to separate generation...")
-    course, quiz = generate_course_and_quiz(params)
-    # Basic scene parsing from course
-    scenes = []
-    sections = re.split(r'\n\d+\.\s*|\n\n', course)
-    sections = [s.strip() for s in sections if s.strip()]
-    for i, section in enumerate(sections[:8]):
-        sentences = section.split('.')
-        title = sentences[0].strip() if sentences else section[:50]
-        content = section.strip()
-        duration = max(5, min(15, len(content.split()) * 0.5))
-        scenes.append({
-            "title": title,
-            "content": content,
-            "duration": int(duration),
-            "visual_prompt": f"{params.get('style', 'cartoon')}, {title}, educational content"
-        })
-    return {
-        "course": course,
-        "quiz": quiz,
-        "video_scenes": scenes
-    }

 from app.core.llm import llm
 from app.prompts.course_prompt import COURSE_TEMPLATE
 from app.prompts.quiz_prompt import QUIZ_TEMPLATE
 import json
 import re
 def generate_course_and_quiz(params):
     course_prompt = PromptTemplate.from_template(COURSE_TEMPLATE)
     course = llm.invoke(
         ]
     return course, quiz

app/services/video_service.py DELETED Viewed

@@ -1,123 +0,0 @@
-import os
-import uuid
-import subprocess
-import time
-from typing import Dict
-from gtts import gTTS
-from pydub import AudioSegment
-import torch
-from diffusers import StableDiffusionPipeline
-class VideoService:
-    def __init__(self):
-        self.pipe = None
-        self._load_model()
-    def _load_model(self):
-        """Load Stable Diffusion model once"""
-        try:
-            self.pipe = StableDiffusionPipeline.from_pretrained(
-                "runwayml/stable-diffusion-v1-5",
-                torch_dtype=torch.float16
-            ).to("cuda")
-        except Exception as e:
-            print(f"Warning: Could not load GPU model, falling back to CPU: {e}")
-            self.pipe = StableDiffusionPipeline.from_pretrained(
-                "runwayml/stable-diffusion-v1-5"
-            )
-    def _ensure_directories(self):
-        """Create necessary directories"""
-        os.makedirs("tmp/images", exist_ok=True)
-        os.makedirs("tmp/audio", exist_ok=True)
-        os.makedirs("output/videos", exist_ok=True)
-    def _generate_image(self, prompt: str, idx: int) -> str:
-        """Generate image for a scene"""
-        image = self.pipe(prompt, num_inference_steps=20).images[0]
-        img_path = f"tmp/images/scene_{idx}.png"
-        image.save(img_path)
-        return img_path
-    def _generate_audio(self, text: str, language: str, idx: int) -> tuple:
-        """Generate audio for a scene"""
-        audio_mp3 = f"tmp/audio/scene_{idx}.mp3"
-        tts = gTTS(text=text, lang=language)
-        tts.save(audio_mp3)
-        # Convert to wav
-        audio_wav = audio_mp3.replace(".mp3", ".wav")
-        subprocess.run(["ffmpeg", "-y", "-i", audio_mp3, audio_wav], check=True)
-        # Get duration
-        audio_duration = AudioSegment.from_file(audio_wav).duration_seconds
-        return audio_wav, audio_duration
-    def _create_video_segment(self, img_path: str, audio_wav: str, duration: float, idx: int) -> str:
-        """Create a video segment from image and audio"""
-        segment_path = f"tmp/segment_{idx}.mp4"
-        subprocess.run([
-            "ffmpeg", "-y",
-            "-loop", "1", "-i", img_path,
-            "-i", audio_wav,
-            "-c:v", "libx264",
-            "-t", str(duration),
-            "-pix_fmt", "yuv420p",
-            "-c:a", "aac",
-            segment_path
-        ], check=True)
-        return segment_path
-    def _concatenate_segments(self, segments: list) -> str:
-        """Concatenate all video segments"""
-        concat_file = "tmp/segments.txt"
-        with open(concat_file, "w") as f:
-            for seg in segments:
-                f.write(f"file '{os.path.abspath(seg)}'\n")
-        output_video = f"output/videos/course_{uuid.uuid4().hex}.mp4"
-        subprocess.run([
-            "ffmpeg", "-y", "-f", "concat", "-safe", "0",
-            "-i", concat_file,
-            "-c", "copy",
-            output_video
-        ], check=True)
-        return output_video
-    def generate_course_video(self, course_data: Dict) -> str:
-        """Generate a complete course video from course data"""
-        start_time = time.time()
-        self._ensure_directories()
-        segments = []
-        for idx, scene in enumerate(course_data["scenes"]):
-            # Generate image
-            prompt = f"{course_data.get('style', 'cartoon')}, {scene['title']}, {scene['content']}"
-            img_path = self._generate_image(prompt, idx)
-            # Generate audio
-            audio_wav, audio_duration = self._generate_audio(
-                scene["content"],
-                course_data.get("language", "fr"),
-                idx
-            )
-            # Create video segment
-            segment_path = self._create_video_segment(img_path, audio_wav, audio_duration, idx)
-            segments.append(segment_path)
-        # Concatenate all segments
-        output_video = self._concatenate_segments(segments)
-        processing_time = time.time() - start_time
-        print(f"Video generated in {processing_time:.2f} seconds")
-        return output_video
-# Global instance
-video_service = VideoService()

main.py CHANGED Viewed

@@ -1,34 +1,5 @@
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from app.routers import chat, quiz, audio, video, integrated
-app = FastAPI(
-    title="🤖 JANGG AI API",
-    description="API complète pour la génération de contenu éducatif avec IA",
-    version="1.0.0"
-)
-# Configuration CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-# Inclusion des routeurs
-app.include_router(chat.router, prefix="/chat", tags=["Chat"])
-app.include_router(quiz.router, prefix="/quiz", tags=["Quiz"])
-app.include_router(audio.router, prefix="/audio", tags=["Audio"])
-app.include_router(video.router, prefix="/video", tags=["Video"])
-app.include_router(integrated.router, prefix="/integrated", tags=["Integrated"])
-@app.get("/", include_in_schema=False)
-async def root():
-    return {"message": "Bienvenue sur l'API JANGG AI"}
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)

+from app.main import app
 if __name__ == "__main__":
     import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt CHANGED Viewed

@@ -1,16 +1,23 @@
-fastapi>=0.68.0
-uvicorn>=0.15.0
-pydantic>=1.8.0
-gtts>=2.3.0
-pydub>=0.25.1
-python-dotenv>=0.19.0
-diffusers>=0.10.0
-torch>=1.12.0
-torchvision>=0.13.0
-transformers>=4.21.0
-accelerate>=0.12.0
-python-multipart>=0.0.5
-langchain-core
-langchain-groq
-pydantic-settings

+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+python-dotenv>=1.0.0
+pydantic>=2.5.0
+sqlalchemy>=2.0.0
+asyncpg>=0.29.0
+alembic>=1.13.0
+redis>=5.0.0
+openai>=1.3.0
+langchain>=0.0.350
+langchain-groq>=0.0.1
+langchain-community>=0.4.0
+crewai>=0.1.4
+crewai-tools>=0.2.0
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+python-multipart>=0.0.6
+httpx>=0.25.0
+pandas>=2.1.0
+numpy>=1.25.0
+pytest>=7.4.0
+pytest-asyncio>=0.21.0
+gtts>=2.4.0