api/routes/ai_routes.py

from fastapi import APIRouter, HTTPException, Depends
from typing import List, Dict, Any
from loguru import logger
from pydantic import BaseModel

from services.ai_service import ai_service

router = APIRouter()

class ModelConfig(BaseModel):
    provider: str
    model: str
    max_tokens: int = 1000
    temperature: float = 0.7

class BenchmarkRequest(BaseModel):
    prompt: str
    models: List[ModelConfig]

@router.post("/generate")
async def generate_response(
    prompt: str,
    provider: str = "openai",
    model: str = "gpt-3.5-turbo",
    max_tokens: int = 1000,
    temperature: float = 0.7
) -> Dict[str, Any]:
    """
    Generate response using specified AI model.
    
    Parameters:
    - prompt: The input prompt
    - provider: AI provider to use (openai, local, openrouter)
    - model: Model to use
    - max_tokens: Maximum tokens in response
    - temperature: Response temperature
    """
    try:
        response = await ai_service.generate_response(
            prompt=prompt,
            provider=provider,
            model=model,
            max_tokens=max_tokens,
            temperature=temperature
        )
        return response
    except Exception as e:
        logger.error(f"Error generating response: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

@router.post("/benchmark")
async def benchmark_models(request: BenchmarkRequest) -> List[Dict[str, Any]]:
    """
    Benchmark multiple models with the same prompt.
    
    Parameters:
    - request: Benchmark request containing prompt and model configurations
    """
    try:
        results = await ai_service.benchmark_models(
            prompt=request.prompt,
            models=[model.dict() for model in request.models]
        )
        return results
    except Exception as e:
        logger.error(f"Error benchmarking models: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))

@router.get("/available-models")
async def get_available_models() -> Dict[str, List[str]]:
    """Get list of available models for each provider."""
    return {
        "openai": [
            "gpt-3.5-turbo",
            "gpt-4",
            "gpt-4-turbo"
        ],
        "openrouter": [
            "anthropic/claude-2",
            "google/palm-2",
            "meta-llama/llama-2-70b"
        ],
        "local": [
            "llama-2-7b",
            "llama-2-13b",
            "llama-2-70b"
        ]
    }

@router.post("/validate-response")
async def validate_response(
    prompt: str,
    response: str,
    provider: str = "openai",
    model: str = "gpt-3.5-turbo"
) -> Dict[str, Any]:
    """
    Validate AI response against the prompt.
    
    Parameters:
    - prompt: Original prompt
    - response: AI-generated response
    - provider: AI provider used
    - model: Model used
    """
    try:
        validation_prompt = f"""
        Validate if the following response adequately addresses the prompt:
        
        Prompt:
        {prompt}
        
        Response:
        {response}
        
        Provide:
        1. Relevance score (0-1)
        2. Completeness score (0-1)
        3. Specific feedback
        """
        
        validation = await ai_service.generate_response(
            prompt=validation_prompt,
            provider=provider,
            model=model
        )
        
        return {
            "status": "success",
            "validation": validation["response"]
        }
    except Exception as e:
        logger.error(f"Error validating response: {str(e)}")
        raise HTTPException(status_code=500, detail=str(e))