> ## 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.

# Utiliser CrewAI avec CometAPI

> Utilisez quatre configurations de transport LLM CrewAI avec CometAPI dans un seul Crew multi-agent séquentiel.

[CrewAI](https://docs.crewai.com/) est un framework Python permettant de coordonner des agents et des tâches d’IA. Ce guide configure un Crew séquentiel pour appeler CometAPI via quatre configurations de transport CrewAI : OpenAI Chat Completions, OpenAI Responses, Anthropic Messages et Gemini `generateContent`.

## Prérequis

* Python 3.10–3.13
* [`uv`](https://docs.astral.sh/uv/getting-started/installation/)
* Un compte CometAPI avec une clé API active — [obtenez la vôtre dans le tableau de bord](https://www.cometapi.com/console/token)
* Quatre ID de modèles de texte pour les transports présentés ci-dessous

## Configurer l’intégration

<Steps>
  <Step title="Créer un projet et installer CrewAI">
    Créez un nouveau projet `uv` et installez CrewAI avec ses extensions Anthropic et Google Gen AI :

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

  <Step title="Définir votre clé API et les ID de modèles">
    Définissez la clé API CometAPI et un ID de modèle pour chaque transport :

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

    Remplacez chaque valeur `your-model-id` par un ID de modèle provenant de la [page des modèles CometAPI](/fr/overview/models). Les quatre valeurs peuvent être différentes. Attribuez chaque ID de modèle au transport correspondant.
  </Step>

  <Step title="Créer le Crew séquentiel">
    Enregistrez l’exemple suivant sous le nom `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}")
    ```

    Les Agents n’ont aucun outil, ne peuvent pas déléguer et s’exécutent un à la fois. Chaque Task après la première déclare les Tasks précédentes dans `context`, afin que CrewAI inclue ces sorties antérieures dans la Task suivante.
  </Step>

  <Step title="Exécuter le Crew">
    Exécutez l’exemple dans la même session shell :

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

    Le script affiche les résultats des quatre Tasks, y compris le brief de publication final.
  </Step>
</Steps>

## Mappage des routes

| Configuration CrewAI                                        | Route CometAPI                                | URL de 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/` préfixe de modèle                              | `POST /v1/messages`                           | `https://api.cometapi.com`    |
| `gemini/` préfixe de modèle et `client_params.http_options` | `POST /v1beta/models/{model}:generateContent` | `https://api.cometapi.com`    |

Les deux configurations OpenAI ci-dessus nécessitent le suffixe `/v1` dans `base_url`. Les configurations Anthropic et Gemini ajoutent leur propre route versionnée, donc leur URL de base est l’origine CometAPI sans `/v1`.

## Choisir les ID de modèles

Utilisez la [page des modèles CometAPI](/fr/overview/models) pour choisir un ID de modèle de texte pour chaque transport. Stockez les ID de modèles dans des variables d’environnement afin de pouvoir les modifier sans éditer le fichier Python. N’ajoutez pas de préfixe de fournisseur à une variable d’environnement. L’exemple ajoute `anthropic/` et `gemini/` là où CrewAI utilise ces préfixes pour la sélection du fournisseur.

## Résolution des problèmes

<AccordionGroup>
  <Accordion title="Les imports du fournisseur Anthropic ou Gemini échouent">
    Exécutez `uv add 'crewai[anthropic,google-genai]'` dans le projet. Le package CrewAI de base n’installe pas les deux SDK de fournisseur facultatifs par défaut.
  </Accordion>

  <Accordion title="Une requête Responses renvoie une erreur de paramètre">
    Supprimez les paramètres facultatifs qui ne font pas partie de l’interface du modèle sélectionné. L’exemple configure uniquement la limite de Tokens de sortie pour Responses.
  </Accordion>

  <Accordion title="Une requête utilise la mauvaise route">
    Comparez la configuration `LLM` avec le tableau de mappage des routes. En particulier, utilisez `custom_openai=True` avec la valeur `api` correcte et conservez l’URL de base Gemini dans `client_params.http_options`.
  </Accordion>
</AccordionGroup>

## Ressources associées

* [Documentation LLM de CrewAI 1.15.12](https://docs.crewai.com/v1.15.12/en/concepts/llms)
* [Agents CrewAI](https://docs.crewai.com/v1.15.12/en/concepts/agents)
* [Tasks CrewAI](https://docs.crewai.com/v1.15.12/en/concepts/tasks)
* [Crews CrewAI](https://docs.crewai.com/v1.15.12/en/concepts/crews)
* [Chat Completions CometAPI](/fr/api/text/chat)
* [Responses CometAPI](/fr/api/text/responses)
* [Anthropic Messages CometAPI](/fr/api/text/anthropic-messages)
* [Gemini generateContent CometAPI](/fr/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": "Utiliser CrewAI avec CometAPI",
        "description": "Utilisez quatre configurations de transport LLM CrewAI avec CometAPI dans un seul Crew multi-agent séquentiel.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-1",
            "position": 1,
            "name": "Créer un projet et installer CrewAI",
            "text": "Créez un projet uv et installez CrewAI avec les extensions Anthropic et Google Gen AI."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-2",
            "position": 2,
            "name": "Définir votre clé API et les ID de modèles",
            "text": "Définissez la clé API CometAPI et un ID de modèle actuel pour chaque transport."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-3",
            "position": 3,
            "name": "Créer le Crew séquentiel",
            "text": "Configurez quatre adaptateurs LLM, quatre Agents et quatre Tasks liées par contexte dans un Crew séquentiel."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/integrations/crewai#step-4",
            "position": 4,
            "name": "Exécuter le Crew",
            "text": "Exécutez le Crew et examinez les résultats des quatre Tasks."
          }
        ]
      },
      {
        "@type": "BreadcrumbList",
        "itemListElement": [
          {
            "@type": "ListItem",
            "position": 1,
            "name": "Documentation CometAPI",
            "item": "https://apidoc.cometapi.com/"
          },
          {
            "@type": "ListItem",
            "position": 2,
            "name": "Intégrations",
            "item": "https://apidoc.cometapi.com/integrations"
          },
          {
            "@type": "ListItem",
            "position": 3,
            "name": "Utiliser CrewAI avec CometAPI",
            "item": "https://apidoc.cometapi.com/integrations/crewai"
          }
        ]
      }
    ]
    }
    `}
</script>