Deploy Real-Time Factory Agent APIs with Agno and FastAPI

"""
Production implementation for deploying real-time factory agent APIs.
Provides secure, scalable operations with Agno framework.
"""
from typing import Dict, Any, List
import os
import logging
import httpx
from fastapi import FastAPI, HTTPException, BackgroundTasks
from sqlalchemy import create_engine, text
from sqlalchemy.orm import sessionmaker

# Logger setup
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Configuration class with environment variables
class Config:
    DATABASE_URL: str = os.getenv('DATABASE_URL')
    AGNO_API_URL: str = os.getenv('AGNO_API_URL')

# Database connection pooling setup
engine = create_engine(Config.DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# FastAPI application
app = FastAPI()

async def validate_input(data: Dict[str, Any]) -> bool:
    """
    Validate request data.
    
    Args:
        data: Input data to validate
    Returns:
        True if valid
    Raises:
        ValueError: If validation fails
    """
    if 'agent_id' not in data:
        raise ValueError('Missing agent_id')  # Ensure required field is present
    if not isinstance(data['agent_id'], str):
        raise ValueError('agent_id must be a string')
    return True

async def sanitize_fields(data: Dict[str, Any]) -> Dict[str, Any]:
    """
    Sanitize input fields to ensure safety.
    
    Args:
        data: Input data to sanitize
    Returns:
        Sanitized data
    """
    return {key: str(value).strip() for key, value in data.items()}  # Strip whitespace

async def fetch_data(agent_id: str) -> Dict[str, Any]:
    """
    Fetch data from Agno API.
    
    Args:
        agent_id: Identifier for the agent
    Returns:
        Data retrieved from the API
    Raises:
        HTTPException: If the API call fails
    """
    async with httpx.AsyncClient() as client:
        response = await client.get(f"{Config.AGNO_API_URL}/agents/{agent_id}")
        if response.status_code != 200:
            raise HTTPException(status_code=response.status_code, detail="API call failed")
        return response.json()

async def save_to_db(data: Dict[str, Any]) -> None:
    """
    Save agent data to the database.
    
    Args:
        data: Data to save
    Raises:
        Exception: If saving fails
    """
    with SessionLocal() as session:
        try:
            session.execute(text("INSERT INTO agents (id, data) VALUES (:id, :data)"), 
                           {'id': data['agent_id'], 'data': data})
            session.commit()  # Commit transaction
        except Exception as e:
            logger.error(f"Error saving to DB: {e}")
            raise

async def format_output(data: Dict[str, Any]) -> Dict[str, Any]:
    """
    Format output data for response.
    
    Args:
        data: Raw data to format
    Returns:
        Formatted output
    """
    return {'status': 'success', 'data': data}  # Simplified response structure

@app.post("/agents/")
async def create_agent(data: Dict[str, Any], background_tasks: BackgroundTasks) -> Dict[str, Any]:
    """
    Create a new agent and process its data.
    
    Args:
        data: Agent data to process
    BackgroundTasks: Task to run in the background
    Returns:
        Response indicating success
    Raises:
        HTTPException: If validation or processing fails
    """
    try:
        await validate_input(data)  # Validate input data
        sanitized_data = await sanitize_fields(data)  # Sanitize fields
        agent_data = await fetch_data(sanitized_data['agent_id'])  # Fetch data from API
        await save_to_db(agent_data)  # Save to database
        background_tasks.add_task(save_to_db, agent_data)  # Save in background for scalability
        return await format_output(agent_data)  # Format output
    except ValueError as ve:
        logger.warning(f"Validation error: {ve}")
        raise HTTPException(status_code=400, detail=str(ve))  # Handle validation errors
    except Exception as e:
        logger.error(f"Unexpected error: {e}")
        raise HTTPException(status_code=500, detail="Internal server error")  # Handle unexpected errors

if __name__ == '__main__':
    # Example usage placeholder
    logger.info("Starting the API server...")
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)  # Run the FastAPI application