Sistema Multi-Agente — Pipeline de Contenido

# cultiva_agents/agents.py
# Sistema multi-agente para pipeline de contenido de marketing
# CULTIVA IA — Agencia de IA marca blanca

from semantic_kernel import Kernel
from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.functions import kernel_function
import os

# ── Kernel compartido ────────────────────────────────────────────
def create_kernel(model: str = "gpt-4o") -> Kernel:
    kernel = Kernel()
    kernel.add_service(
        AzureChatCompletion(
            deployment_name=model,
            endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
            api_key=os.environ["AZURE_OPENAI_KEY"],
        )
    )
    return kernel


# ── Herramientas reutilizables ───────────────────────────────────
class MarketingTools:
    @kernel_function(description="Recupera datos de tendencias de busqueda para un sector")
    def get_trends(self, sector: str) -> str:
        # Integrar con SerpAPI / Google Trends en produccion
        return f"[Tendencias actuales para {sector}: IA generativa +340%, automatizacion +89%]"

    @kernel_function(description="Analiza competidores principales de un cliente")
    def analyze_competitors(self, company: str, sector: str) -> str:
        # Integrar con Semrush / Ahrefs API en produccion
        return f"[Competidores de {company} en {sector}: dominio_autoritad, backlinks, keywords clave]"


# ── Definicion de los 4 agentes ──────────────────────────────────
def build_agents() -> dict:
    kernel_full  = create_kernel("gpt-4o")
    kernel_mini  = create_kernel("gpt-4o-mini")

    # Anadir herramientas al kernel del investigador
    kernel_full.add_plugin(MarketingTools(), plugin_name="marketing_tools")

    investigador = ChatCompletionAgent(
        kernel=kernel_full,
        name="Investigador",
        instructions="""Eres un analista de mercado senior especializado en marketing digital B2B.
        Dado un cliente y sector, usa las herramientas disponibles para:
        - Identificar tendencias del sector (ultimos 6 meses)
        - Analizar 3 competidores principales
        - Detectar oportunidades de contenido poco exploradas
        Devuelve un informe estructurado con bullets. Maximo 400 palabras.""",
    )

    estratega = ChatCompletionAgent(
        kernel=kernel_full,
        name="Estratega",
        instructions="""Eres un estratega de contenido con enfoque en conversion B2B.
        Con el informe de investigacion, define:
        - 3 angulos narrativos diferenciadores
        - Mensaje clave para cada pieza de contenido
        - Tono y voz recomendados para la marca
        - Llamadas a la accion prioritarias
        Sé especifico y accionable.""",
    )

    redactor = ChatCompletionAgent(
        kernel=kernel_full,
        name="Redactor",
        instructions="""Eres un redactor creativo especializado en contenido de marketing para tecnologia.
        Con la estrategia definida, produce:
        - 1 post de LinkedIn (150-200 palabras, con hook potente)
        - 1 email de nurturing (asunto + cuerpo, 120 palabras)
        - 3 titulares alternativos para blog
        Usa el tono y angulos definidos por el Estratega. No uses emojis en exceso.""",
    )

    editor = ChatCompletionAgent(
        kernel=kernel_mini,  # gpt-4o-mini basta para revision
        name="Editor",
        instructions="""Eres un editor senior. Revisa el contenido del Redactor y verifica:
        1. Coherencia con la estrategia definida
        2. Claridad y fluidez de lectura
        3. Ausencia de clichés o lenguaje corporativo vacio
        4. Llamada a la accion clara y convincente
        Si todo esta correcto, responde EXACTAMENTE: "APROBADO"
        Si necesita cambios, responde: "REVISION: [lista de mejoras concretas]"
        Maximo 2 rondas de revision antes de aprobar.""",
    )

    return {
        "investigador": investigador,
        "estratega": estratega,
        "redactor": redactor,
        "editor": editor,
    }

# api.py — endpoint listo para conectar con n8n, Make o webhook de Slack
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from contextlib import asynccontextmanager
from .agents import build_agents, create_kernel
from .orchestration import run_sequential_pipeline, parallel_research

# ── Modelos de entrada / salida ──────────────────────────────────
class ContentRequest(BaseModel):
    cliente:       str     # ej. "Legalia Tech — plataforma LegalTech B2B"
    sector:        str     # ej. "legaltech"
    tipo_contenido: str   # ej. "post LinkedIn + email nurturing"
    objetivo:      str     # ej. "generar leads de despachos medianos"
    tono:          str = "profesional-cercano"

class ContentResponse(BaseModel):
    status:   str          # "ok" | "error"
    pipeline: str          # transcripcion completa de todos los agentes
    resumen:  str          # extraccion del contenido final aprobado

# ── App lifecycle ────────────────────────────────────────────────
_agents = {}
_kernel = None

@asynccontextmanager
async def lifespan(app: FastAPI):
    global _agents, _kernel
    _agents = build_agents()           # Crea agentes una vez al arrancar
    _kernel = create_kernel("gpt-4o")   # Kernel compartido para orquestacion
    yield
    # Cleanup si fuera necesario

app = FastAPI(
    title="CULTIVA IA — Content Pipeline API",
    description="Sistema multi-agente para produccion automatica de contenido de marketing",
    version="1.0.0",
    lifespan=lifespan,
)

# ── Endpoint principal ───────────────────────────────────────────
@app.post("/pipeline/content", response_model=ContentResponse)
async def content_pipeline(req: ContentRequest):
    """
    Ejecuta el pipeline completo:
    1. Investigacion paralela (sector + competidores + tendencias)
    2. Pipeline secuencial (estrategia -> redaccion -> edicion)
    Retorna el contenido final aprobado por el Editor.
    """
    try:
        # Paso 1: investigacion paralela (fan-out)
        research = await parallel_research(
            _kernel, req.cliente, req.sector
        )

        # Paso 2: pipeline secuencial con hallazgos de investigacion
        brief = (
            f"CLIENTE: {req.cliente}\n"
            f"SECTOR: {req.sector}\n"
            f"OBJETIVO: {req.objetivo}\n"
            f"TIPO CONTENIDO: {req.tipo_contenido}\n"
            f"TONO: {req.tono}\n\n"
            f"INVESTIGACION PREVIA:\n{research}"
        )

        pipeline_output = await run_sequential_pipeline(
            _agents, brief, _kernel
        )

        # Extraer bloque final aprobado (ultimo mensaje del Redactor antes de APROBADO)
        lines = pipeline_output.split("\n")
        final_content = "\n".join(
            l for l in lines
            if not l.startswith("[Editor]") and "APROBADO" not in l
        ).strip()

        return ContentResponse(
            status="ok",
            pipeline=pipeline_output,
            resumen=final_content,
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# Iniciar: uvicorn cultiva_agents.api:app --reload --port 8000