Desarrollo de Software
e Integración de IA

# domain/ports.py - Principio de Inversión de Dependencias
from abc import ABC, abstractmethod
from typing import AsyncGenerator

class AIServicePort(ABC):
    """Interfaz abstracta para servicios de IA"""

    @abstractmethod
    async def stream_response(
        self, message: str, max_tokens: int
    ) -> AsyncGenerator[str, None]:
        pass

# infrastructure/anthropic_adapter.py - Patrón Adapter
from anthropic import AsyncAnthropic, APIError
import backoff
import logging

class AnthropicAdapter(AIServicePort):
    def __init__(self, api_key: str):
        self.client = AsyncAnthropic(api_key=api_key)

    @backoff.on_exception(backoff.expo, (APIError,), max_tries=3)
    async def stream_response(
        self, message: str, max_tokens: int = 1024
    ) -> AsyncGenerator[str, None]:
        async with self.client.messages.stream(
            model='claude-sonnet-4-5-20250929',
            max_tokens=max_tokens,
            messages=[{"role": "user", "content": message}]
        ) as stream:
            async for text in stream.text_stream:
                yield text

# api/endpoints/chat.py - Capa de Presentación
from fastapi import FastAPI, Depends, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel, Field
from slowapi import Limiter
from slowapi.util import get_remote_address

app = FastAPI()
limiter = Limiter(key_func=get_remote_address)

def get_ai_service() -> AIServicePort:
    api_key = os.getenv("ANTHROPIC_API_KEY")
    return AnthropicAdapter(api_key=api_key)

class ChatRequest(BaseModel):
    message: str = Field(..., min_length=1, max_length=10000)
    max_tokens: int = Field(default=1024, ge=1, le=4096)

@app.post("/api/chat")
@limiter.limit("20/minute")
async def chat_endpoint(
    request: ChatRequest,
    ai_service: AIServicePort = Depends(get_ai_service)
):
    async def generate():
        async for text in ai_service.stream_response(
            request.message, request.max_tokens
        ):
            yield f"data: {text}\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
        headers={"Cache-Control": "no-cache"}
    )