> ## 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 quattro configurazioni di trasporto LLM di CrewAI con CometAPI in un unico Crew sequenziale multi-agente.

[CrewAI](https://docs.crewai.com/) è un framework Python per coordinare agenti e attività di IA. Questa guida configura un Crew sequenziale per chiamare CometAPI tramite quattro configurazioni di trasporto CrewAI: OpenAI Chat Completions, OpenAI Responses, Anthropic Messages e Gemini `generateContent`.

## Prerequisiti

* Python 3.10–3.13
* [`uv`](https://docs.astral.sh/uv/getting-started/installation/)
* Un account CometAPI con una chiave API attiva — [ottienila nella dashboard](https://www.cometapi.com/console/token)
* Quattro ID modello di testo per i trasporti mostrati di seguito

## Configura l'integrazione

<Steps>
  <Step title="Crea un progetto e installa CrewAI">
    Crea un nuovo progetto `uv` e installa CrewAI con gli extra per Anthropic e Google Gen AI:

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

  <Step title="Imposta la chiave API e gli ID modello">
    Imposta la chiave API di CometAPI e un ID modello per ciascun trasporto:

    ```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
    ```

    Sostituisci ogni valore `your-model-id` con un ID modello dalla [pagina Modelli di CometAPI](/it/overview/models). I quattro valori possono essere diversi. Assegna ogni ID modello al trasporto corrispondente.
  </Step>

  <Step title="Crea il Crew sequenziale">
    Salva l'esempio seguente come `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}")
    ```

    Gli Agents non hanno strumenti, non possono delegare e vengono eseguiti uno alla volta. Ogni Task successiva alla prima dichiara le Task precedenti in `context`, quindi CrewAI include tali output precedenti nella Task successiva.
  </Step>

  <Step title="Esegui il Crew">
    Esegui l'esempio nella stessa sessione shell:

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

    Lo script stampa tutti e quattro gli output delle Task, incluso il brief finale di rilascio.
  </Step>
</Steps>

## Mappatura delle route

| Configurazione CrewAI                                         | Route CometAPI                                | URL di 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/` prefisso del modello                             | `POST /v1/messages`                           | `https://api.cometapi.com`    |
| `gemini/` prefisso del modello e `client_params.http_options` | `POST /v1beta/models/{model}:generateContent` | `https://api.cometapi.com`    |

Le due configurazioni OpenAI precedenti richiedono il suffisso `/v1` in `base_url`. Le configurazioni Anthropic e Gemini aggiungono una propria route con versione, quindi il loro URL di base è l'origine CometAPI senza `/v1`.

## Scegli gli ID modello

Usa la [pagina Modelli di CometAPI](/it/overview/models) per scegliere un ID modello di testo per ciascun trasporto. Memorizza gli ID modello nelle variabili d'ambiente, così potrai modificarli senza modificare il file Python. Non aggiungere un prefisso del provider a una variabile d'ambiente. L'esempio aggiunge `anthropic/` e `gemini/` dove CrewAI usa tali prefissi per la selezione del provider.

## Risoluzione dei problemi

<AccordionGroup>
  <Accordion title="Le importazioni dei provider Anthropic o Gemini non riescono">
    Esegui `uv add 'crewai[anthropic,google-genai]'` nel progetto. Il pacchetto CrewAI di base non installa entrambi gli SDK dei provider opzionali per impostazione predefinita.
  </Accordion>

  <Accordion title="Una richiesta Responses restituisce un errore relativo a un parametro">
    Rimuovi i parametri opzionali che non fanno parte dell'interfaccia del modello selezionato. L'esempio configura solo il limite di Token di output per Responses.
  </Accordion>

  <Accordion title="Una richiesta usa la route errata">
    Confronta la configurazione `LLM` con la tabella di mappatura delle route. In particolare, usa `custom_openai=True` con il valore `api` corretto e mantieni l'URL di base Gemini all'interno di `client_params.http_options`.
  </Accordion>
</AccordionGroup>

## Risorse correlate

* [Documentazione LLM di CrewAI 1.15.12](https://docs.crewai.com/v1.15.12/en/concepts/llms)
* [CrewAI Agents](https://docs.crewai.com/v1.15.12/en/concepts/agents)
* [CrewAI Tasks](https://docs.crewai.com/v1.15.12/en/concepts/tasks)
* [CrewAI Crews](https://docs.crewai.com/v1.15.12/en/concepts/crews)
* [CometAPI Chat Completions](/it/api/text/chat)
* [CometAPI Responses](/it/api/text/responses)
* [CometAPI Anthropic Messages](/it/api/text/anthropic-messages)
* [CometAPI Gemini generateContent](/it/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 quattro configurazioni di trasporto LLM di CrewAI con CometAPI in un unico Crew sequenziale multi-agente.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-1",
            "position": 1,
            "name": "Crea un progetto e installa CrewAI",
            "text": "Crea un progetto uv e installa CrewAI con gli extra per Anthropic e Google Gen AI."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-2",
            "position": 2,
            "name": "Imposta la chiave API e gli ID modello",
            "text": "Imposta la chiave API di CometAPI e un ID modello corrente per ciascun trasporto."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-3",
            "position": 3,
            "name": "Crea il Crew sequenziale",
            "text": "Configura quattro adattatori LLM, quattro Agents e quattro Tasks collegati tramite contesto in un Crew sequenziale."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-4",
            "position": 4,
            "name": "Esegui il Crew",
            "text": "Esegui il Crew e controlla tutti e quattro gli output delle Task."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "CometAPI Docs",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Integrazioni",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Usa CrewAI con CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/crewai"
          }
        ]
      }
    ]
    }
    `}
</script>