cd backend
uv add openai langchain langchain-openai tiktoken

# Optional: Add other AI providers as needed
uv add anthropic google-generativeai cohere

[project]
dependencies = [
    # ... existing dependencies ...
    "openai>=1.0.0",
    "langchain>=0.1.0",
    "langchain-openai>=0.1.0",
    "tiktoken>=0.5.0",
]

[project.optional-dependencies]
ai-providers = [
    "anthropic>=0.7.0",
    "google-generativeai>=0.3.0",
    "cohere>=4.0.0",
]

uv sync --all-extras

# OpenAI (Most Popular)
OPENAI_API_KEY=your_key_here
OPENAI_MODEL=gpt-4o-mini

# Anthropic Claude
ANTHROPIC_API_KEY=your_key_here

# Google Gemini
GOOGLE_API_KEY=your_key_here

from celery_setup import celery_app
from openai import OpenAI
from app.db.database import SyncSessionLocal
from sqlalchemy import select
import os

@celery_app.task()
def analyze_text(text: str, analysis_type: str = "sentiment", user_id: int = None):
    """Analyze text using AI - runs in background"""
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

    prompts = {
        "sentiment": f"Analyze the sentiment of this text: {text}",
        "summary": f"Summarize this text in 2-3 sentences: {text}",
        "keywords": f"Extract 5 key topics from this text: {text}"
    }

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompts[analysis_type]}],
        temperature=0.3,
        max_tokens=500
    )

    # Save result to database using synchronous session
    db = SyncSessionLocal()
    try:
        # Save AI analysis result
        ai_result = AIAnalysis(
            user_id=user_id,
            input_text=text,
            analysis_type=analysis_type,
            result=response.choices[0].message.content,
            model_used="gpt-4o-mini",
            tokens_used=response.usage.total_tokens,
            cost=calculate_cost(response.usage.total_tokens, "gpt-4o-mini")
        )
        db.add(ai_result)
        db.commit()
        db.refresh(ai_result)

        return {
            "success": True,
            "result": response.choices[0].message.content,
            "analysis_id": ai_result.id
        }
    finally:
        db.close()

def calculate_cost(tokens: int, model: str) -> float:
    """Calculate API cost based on tokens and model"""
    pricing = {
        "gpt-4o-mini": 0.00015 / 1000,  # per 1K tokens
        "gpt-4o": 0.0025 / 1000,
        "claude-3-5-sonnet-20241022": 0.003 / 1000,
    }
    return tokens * pricing.get(model, 0)

class PromptBuilder:
    @staticmethod
    def create_system_prompt(role: str, context: str = ""):
        """Create consistent system prompts"""
        base = f"You are a {role}."
        if context:
            base += f" Context: {context}"
        return base

    @staticmethod
    def create_task_prompt(task: str, input_data: str, format_instructions: str = ""):
        """Create structured task prompts"""
        prompt = f"Task: {task}\n\nInput: {input_data}"
        if format_instructions:
            prompt += f"\n\nFormat your response as: {format_instructions}"
        return prompt

# Usage in Celery task
@celery_app.task()
def analyze_with_structured_prompt(text: str):
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

    system_prompt = PromptBuilder.create_system_prompt(
        "data analyst",
        "specialized in sentiment analysis"
    )
    task_prompt = PromptBuilder.create_task_prompt(
        "sentiment analysis",
        text,
        "JSON with keys: sentiment, confidence, reasoning"
    )

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": task_prompt}
        ]
    )

    return response.choices[0].message.content

def create_classification_prompt(text: str, categories: list):
    """Use examples to improve classification accuracy"""
    examples = """
    Examples:
    Text: "I love this product!" → Category: positive
    Text: "This is terrible" → Category: negative
    Text: "It's okay, nothing special" → Category: neutral
    """

    return f"""
    {examples}

    Classify this text into one of these categories: {', '.join(categories)}
    Text: "{text}"
    Category:
    """

def create_reasoning_prompt(problem: str):
    """Encourage step-by-step thinking"""
    return f"""
    Solve this problem step by step:
    {problem}

    Think through this by:
    1. Understanding what's being asked
    2. Identifying key information
    3. Working through the solution
    4. Providing your final answer

    Let's work through this step by step:
    """

import tiktoken

def estimate_tokens(text: str, model: str = "gpt-4o-mini") -> int:
    """Estimate token count before API call"""
    encoding = tiktoken.encoding_for_model(model)
    return len(encoding.encode(text))

def optimize_prompt(prompt: str, max_tokens: int = 4000) -> str:
    """Truncate prompt if too long"""
    if estimate_tokens(prompt) > max_tokens:
        # Truncate from middle, keep beginning and end
        words = prompt.split()
        target_words = len(words) * max_tokens // estimate_tokens(prompt)

        start_words = words[:target_words//2]
        end_words = words[-target_words//2:]

        return " ".join(start_words) + "\n...[truncated]...\n" + " ".join(end_words)

    return prompt

import hashlib
import json
from datetime import datetime, timedelta
from app.db.database import SyncSessionLocal
from sqlalchemy import select
from celery_setup import celery_app

def cache_ai_response(expiry_hours: int = 24):
    """Cache AI responses to reduce API calls"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            # Create cache key
            cache_key = hashlib.md5(
                json.dumps({"func": func.__name__, "args": args, "kwargs": kwargs}, sort_keys=True).encode()
            ).hexdigest()

            db = SyncSessionLocal()
            try:
                # Check cache in database
                result = db.execute(
                    select(AICache).where(
                        AICache.cache_key == cache_key,
                        AICache.expires_at > datetime.utcnow()
                    )
                )
                cached_result = result.scalar_one_or_none()

                if cached_result:
                    return json.loads(cached_result.result)

                # Execute function
                result = func(*args, **kwargs)

                # Cache result in database
                cache_record = AICache(
                    cache_key=cache_key,
                    result=json.dumps(result),
                    expires_at=datetime.utcnow() + timedelta(hours=expiry_hours)
                )
                db.add(cache_record)
                db.commit()

                return result
            finally:
                db.close()
        return wrapper
    return decorator

# Usage
@celery_app.task()
@cache_ai_response(expiry_hours=24)
def cached_analysis(text: str):
    """This result will be cached for 24 hours"""
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": text}]
    )
    return response.choices[0].message.content