> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Usa CrewAI con CometAPI

> Usa cuatro configuraciones de transporte LLM de CrewAI con CometAPI en un único Crew secuencial de varios agentes.

[CrewAI](https://docs.crewai.com/) es un framework de Python para coordinar agentes y tareas de IA. Esta guía configura un Crew secuencial para llamar a CometAPI mediante cuatro configuraciones de transporte de CrewAI: OpenAI Chat Completions, OpenAI Responses, Anthropic Messages y Gemini `generateContent`.

## Requisitos previos

* Python 3.10–3.13
* [`uv`](https://docs.astral.sh/uv/getting-started/installation/)
* Una cuenta de CometAPI con una clave de API activa — [obtén la tuya en el panel](https://www.cometapi.com/console/token)
* Cuatro ID de modelos de texto para los transportes que se muestran a continuación

## Configura la integración

<Steps>
  <Step title="Crea un proyecto e instala CrewAI">
    Crea un nuevo proyecto de `uv` e instala CrewAI con sus extras de Anthropic y Google Gen AI:

    ```bash theme={null}
    uv init crewai-cometapi
    cd crewai-cometapi
    uv add 'crewai[anthropic,google-genai]'
    ```
  </Step>

  <Step title="Configura tu clave de API y los ID de modelo">
    Configura la clave de API de CometAPI y un ID de modelo para cada transporte:

    ```bash theme={null}
    read -rsp "CometAPI API key: " COMETAPI_KEY
    printf '\n'
    export COMETAPI_KEY

    export COMETAPI_CHAT_MODEL_ID=your-model-id
    export COMETAPI_RESPONSES_MODEL_ID=your-model-id
    export COMETAPI_ANTHROPIC_MODEL_ID=your-model-id
    export COMETAPI_GEMINI_MODEL_ID=your-model-id
    ```

    Reemplaza cada valor de `your-model-id` por un ID de modelo de la [página de modelos de CometAPI](/es/overview/models). Los cuatro valores pueden ser diferentes. Asigna cada ID de modelo a su transporte correspondiente.
  </Step>

  <Step title="Crea el Crew secuencial">
    Guarda el siguiente ejemplo como `crew.py`:

    ```python theme={null}
    import os

    from crewai import Agent, Crew, LLM, Process, Task


    api_key = os.environ["COMETAPI_KEY"]

    chat_llm = LLM(
        model=os.environ["COMETAPI_CHAT_MODEL_ID"],
        custom_openai=True,
        api="completions",
        base_url="https://api.cometapi.com/v1",
        api_key=api_key,
        max_tokens=512,
        max_retries=0,
    )

    responses_llm = LLM(
        model=os.environ["COMETAPI_RESPONSES_MODEL_ID"],
        custom_openai=True,
        api="responses",
        base_url="https://api.cometapi.com/v1",
        api_key=api_key,
        max_completion_tokens=512,
        max_retries=0,
    )

    anthropic_llm = LLM(
        model=f"anthropic/{os.environ['COMETAPI_ANTHROPIC_MODEL_ID']}",
        base_url="https://api.cometapi.com",
        api_key=api_key,
        max_tokens=512,
        max_retries=0,
    )

    gemini_llm = LLM(
        model=f"gemini/{os.environ['COMETAPI_GEMINI_MODEL_ID']}",
        api_key=api_key,
        max_output_tokens=512,
        thinking_config={"thinking_budget": 0, "include_thoughts": False},
        client_params={
            "http_options": {
                "base_url": "https://api.cometapi.com",
                "api_version": "v1beta",
            }
        },
    )

    audience_agent = Agent(
        role="Audience researcher",
        goal="Define the audience for an API migration brief",
        backstory="You turn product goals into a precise audience statement.",
        llm=chat_llm,
        tools=[],
        allow_delegation=False,
        max_iter=1,
        max_retry_limit=0,
        verbose=False,
    )

    requirements_agent = Agent(
        role="Requirements planner",
        goal="Turn an audience statement into implementation requirements",
        backstory="You write concise, testable requirements for API teams.",
        llm=responses_llm,
        tools=[],
        allow_delegation=False,
        max_iter=1,
        max_retry_limit=0,
        verbose=False,
    )

    risk_agent = Agent(
        role="Risk reviewer",
        goal="Identify the most important migration risk",
        backstory="You review plans for practical delivery risks.",
        llm=anthropic_llm,
        tools=[],
        allow_delegation=False,
        max_iter=1,
        max_retry_limit=0,
        verbose=False,
    )

    editor_agent = Agent(
        role="Release brief editor",
        goal="Combine research, requirements, and risk into one brief",
        backstory="You preserve source findings while producing clear summaries.",
        llm=gemini_llm,
        tools=[],
        allow_delegation=False,
        max_iter=1,
        max_retry_limit=0,
        verbose=False,
    )

    audience_task = Task(
        description=(
            "Define one target audience for a team moving an existing OpenAI "
            "integration to a multi-provider API. Return only an Audience heading "
            "and one sentence of at most 20 words."
        ),
        expected_output="An Audience heading followed by one concise sentence.",
        agent=audience_agent,
    )

    requirements_task = Task(
        description=(
            "Using the audience statement in your context, return only a "
            "Requirements heading and exactly two numbered requirements. Keep each "
            "requirement to at most 18 words."
        ),
        expected_output="A Requirements heading followed by two numbered items.",
        agent=requirements_agent,
        context=[audience_task],
    )

    risk_task = Task(
        description=(
            "Using the audience and requirements in your context, return only a "
            "Risk heading, one risk sentence, and one mitigation sentence. Keep "
            "each sentence to at most 18 words."
        ),
        expected_output="A Risk heading with one risk and one mitigation.",
        agent=risk_agent,
        context=[audience_task, requirements_task],
    )

    brief_task = Task(
        description=(
            "Create a release brief from all prior task outputs. Return only these "
            "sections: Audience with one sentence; Requirements with two numbered "
            "items; Risk with one risk and one mitigation. Keep the exact headings "
            "Audience, Requirements, and Risk."
        ),
        expected_output=(
            "A concise release brief with Audience, Requirements, and Risk headings."
        ),
        agent=editor_agent,
        context=[audience_task, requirements_task, risk_task],
    )

    crew = Crew(
        agents=[
            audience_agent,
            requirements_agent,
            risk_agent,
            editor_agent,
        ],
        tasks=[audience_task, requirements_task, risk_task, brief_task],
        process=Process.sequential,
        verbose=False,
    )

    result = crew.kickoff()

    for index, task_output in enumerate(result.tasks_output, start=1):
        print(f"\n--- Task {index} ---\n{task_output.raw}")
    ```

    Los Agents no tienen herramientas, no pueden delegar y se ejecutan de uno en uno. Cada Task después de la primera declara sus Tasks precedentes en `context`, por lo que CrewAI incluye esas salidas anteriores en la siguiente Task.
  </Step>

  <Step title="Ejecuta el Crew">
    Ejecuta el ejemplo en la misma sesión de shell:

    ```bash theme={null}
    uv run python crew.py
    ```

    El script imprime los resultados de las cuatro Task, incluido el informe final de lanzamiento.
  </Step>
</Steps>

## Asignación de rutas

| Configuración de CrewAI                                    | Ruta de CometAPI                              | URL base                      |
| ---------------------------------------------------------- | --------------------------------------------- | ----------------------------- |
| `custom_openai=True`, `api="completions"`                  | `POST /v1/chat/completions`                   | `https://api.cometapi.com/v1` |
| `custom_openai=True`, `api="responses"`                    | `POST /v1/responses`                          | `https://api.cometapi.com/v1` |
| `anthropic/` prefijo de modelo                             | `POST /v1/messages`                           | `https://api.cometapi.com`    |
| `gemini/` prefijo de modelo y `client_params.http_options` | `POST /v1beta/models/{model}:generateContent` | `https://api.cometapi.com`    |

Las dos configuraciones de OpenAI anteriores necesitan el sufijo `/v1` en `base_url`. Las configuraciones de Anthropic y Gemini añaden su propia ruta versionada, por lo que su URL base es el origen de CometAPI sin `/v1`.

## Elige los ID de modelo

Usa la [página de modelos de CometAPI](/es/overview/models) para elegir un ID de modelo de texto para cada transporte. Almacena los ID de modelo en variables de entorno para poder cambiarlos sin editar el archivo de Python. No agregues un prefijo de proveedor a una variable de entorno. El ejemplo agrega `anthropic/` y `gemini/` donde CrewAI usa esos prefijos para la selección de proveedor.

## Solución de problemas

<AccordionGroup>
  <Accordion title="Las importaciones del proveedor Anthropic o Gemini fallan">
    Ejecuta `uv add 'crewai[anthropic,google-genai]'` en el proyecto. El paquete base de CrewAI no instala ambos SDK de proveedores opcionales de forma predeterminada.
  </Accordion>

  <Accordion title="Una solicitud de Responses devuelve un error de parámetro">
    Elimina los parámetros opcionales que no formen parte de la interfaz del modelo seleccionado. El ejemplo configura solo el límite de Tokens de salida para Responses.
  </Accordion>

  <Accordion title="Una solicitud usa la ruta incorrecta">
    Compara la configuración de `LLM` con la tabla de asignación de rutas. En particular, usa `custom_openai=True` con el valor `api` correcto y mantén la URL base de Gemini dentro de `client_params.http_options`.
  </Accordion>
</AccordionGroup>

## Recursos relacionados

* [Documentación de LLM de CrewAI 1.15.12](https://docs.crewai.com/v1.15.12/en/concepts/llms)
* [Agents de CrewAI](https://docs.crewai.com/v1.15.12/en/concepts/agents)
* [Tasks de CrewAI](https://docs.crewai.com/v1.15.12/en/concepts/tasks)
* [Crews de CrewAI](https://docs.crewai.com/v1.15.12/en/concepts/crews)
* [CometAPI Chat Completions](/es/api/text/chat)
* [CometAPI Responses](/es/api/text/responses)
* [CometAPI Anthropic Messages](/es/api/text/anthropic-messages)
* [CometAPI Gemini generateContent](/es/api/text/gemini-generating-content)

<script type="application/ld+json">
  {`
    {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "HowTo",
        "@id": "https://apidoc.cometapi.com/integrations/crewai#howto",
        "name": "Usa CrewAI con CometAPI",
        "description": "Usa cuatro configuraciones de transporte LLM de CrewAI con CometAPI en un único Crew secuencial de varios agentes.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-1",
            "position": 1,
            "name": "Crea un proyecto e instala CrewAI",
            "text": "Crea un proyecto de uv e instala CrewAI con los extras de Anthropic y Google Gen AI."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-2",
            "position": 2,
            "name": "Configura tu clave de API y los ID de modelo",
            "text": "Configura la clave de API de CometAPI y un ID de modelo vigente para cada transporte."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-3",
            "position": 3,
            "name": "Crea el Crew secuencial",
            "text": "Configura cuatro adaptadores LLM, cuatro Agents y cuatro Tasks vinculadas por contexto en un Crew secuencial."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-4",
            "position": 4,
            "name": "Ejecuta el Crew",
            "text": "Ejecuta el Crew e inspecciona los resultados de las cuatro Task."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "Documentación de CometAPI",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integraciones",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Usa CrewAI con CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/crewai"
          }
        ]
      }
    ]
    }
    `}
</script>