Utiliser des Connecteurs dans les conversations

Après qu'un Connecteur est enregistré et authentifié (si nécessaire), vous pouvez l'attacher à n'importe quelle conversation.

Vous pouvez combiner des Connecteurs avec des outils intégrés comme web_search, filtrer les outils que le modèle peut utiliser, et configurer des Connecteurs sur des Agents pour qu'ils soient disponibles dans chaque conversation.

Information

Les outils sont des fonctions exécutables de serveur MCP que le modèle peut appeler. Lorsque vous attachez un Connecteur, le modèle découvre automatiquement ces outils et appelle ceux qui conviennent en fonction de la requête.

Attacher des Connecteurs à une conversation

Usage de base

Passez n'importe quel Connecteur comme tool à une conversation en utilisant type: "connector" et le nom ou l'UUID du Connecteur comme connector_id.

Note

Tous les outils exposés par le Connecteur sont disponibles pour le modèle. Pour restreindre les outils que le modèle peut appeler, consultez Filtrer les outils.

import asyncio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")


async def main() -> None:
    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[
            {
                "role": "user",
                "content": "Using deepwiki, tell me about the structure of the sqlite/sqlite repository.",
            }
        ],
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",  # name or UUID
            },
        ],
    )
    for output in response.outputs:
        if output.type == "message.output":
            print(output.content)


asyncio.run(main())

import asyncio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")


async def main() -> None:
    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[
            {
                "role": "user",
                "content": "Using deepwiki, tell me about the structure of the sqlite/sqlite repository.",
            }
        ],
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",  # name or UUID
            },
        ],
    )
    for output in response.outputs:
        if output.type == "message.output":
            print(output.content)


asyncio.run(main())

Filtrer les outils

Pour contrôler quels outils d'un Connecteur le modèle peut utiliser, ajoutez un objet tool_configuration. Définissez include pour autoriser des outils spécifiques, ou exclude pour les bloquer. Vous pouvez utiliser l'un ou l'autre, mais pas les deux simultanément.

import asyncio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")


async def main() -> None:
    # Exclude specific tools
    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[{"role": "user", "content": "What tools do you have access to?"}],
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
                "tool_configuration": {
                    "exclude": ["read_wiki_structure"],
                },
            },
        ],
    )

    # Include only specific tools
    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[{"role": "user", "content": "What tools do you have access to?"}],
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
                "tool_configuration": {
                    "include": ["ask_question"],
                },
            },
        ],
    )


asyncio.run(main())

import asyncio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")


async def main() -> None:
    # Exclude specific tools
    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[{"role": "user", "content": "What tools do you have access to?"}],
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
                "tool_configuration": {
                    "exclude": ["read_wiki_structure"],
                },
            },
        ],
    )

    # Include only specific tools
    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[{"role": "user", "content": "What tools do you have access to?"}],
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
                "tool_configuration": {
                    "include": ["ask_question"],
                },
            },
        ],
    )


asyncio.run(main())

Astuce

Vous pouvez exiger une approbation utilisateur avant l'exécution d'un outil en ajoutant requires_confirmation à la tool_configuration. C'est utile pour les actions sensibles comme l'envoi d'emails ou la modification de données. Consultez Validation humaine pour le flux de confirmation complet.

Utiliser des outils intégrés avec des Connecteurs

Mistral fournit des outils intégrés tels que web_search, code_interpreter, image_generation et document_library. Vous pouvez les passer aux côtés de Connecteurs dans le même tableau tools. Le modèle décide quel outil appeler en fonction de la requête.

import asyncio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")


async def main() -> None:
    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[
            {
                "role": "user",
                "content": "Search the web for the latest SQLite release, then use deepwiki to find where the version is defined in the sqlite/sqlite repo.",
            }
        ],
        tools=[
            {"type": "web_search"},
            {"type": "connector", "connector_id": "my_deepwiki"},
        ],
    )
    for output in response.outputs:
        if output.type == "message.output":
            print(output.content)


asyncio.run(main())

import asyncio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")


async def main() -> None:
    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[
            {
                "role": "user",
                "content": "Search the web for the latest SQLite release, then use deepwiki to find where the version is defined in the sqlite/sqlite repo.",
            }
        ],
        tools=[
            {"type": "web_search"},
            {"type": "connector", "connector_id": "my_deepwiki"},
        ],
    )
    for output in response.outputs:
        if output.type == "message.output":
            print(output.content)


asyncio.run(main())

Ajouter des Connecteurs à un Agent

Vous pouvez également attacher des Connecteurs directement à un Agent lors de sa création. Chaque conversation démarrée avec cet Agent a alors automatiquement accès aux outils du Connecteur, sans avoir à passer un tableau tools à chaque fois.

Astuce

C'est utile lorsqu'un Agent a toujours besoin des mêmes outils externes (par exemple, un Agent de support qui interroge toujours un CRM).

import asyncio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")


async def main() -> None:
    # Create the agent with a connector
    agent = await client.beta.agents.create_async(
        name="deepwiki_agent",
        description="Agent with DeepWiki access for code repository exploration",
        model="mistral-small-latest",
        instructions="You are a helpful assistant that can explore code repositories using DeepWiki. Be concise.",
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
            },
        ],
    )

    # Start a conversation using the agent — no tools needed here
    response = await client.beta.conversations.start_async(
        agent_id=agent.id,
        inputs=[
            {"role": "user", "content": "What is the main purpose of the sqlite repository?"}
        ],
    )
    for output in response.outputs:
        if output.type == "message.output":
            print(output.content)


asyncio.run(main())

import asyncio
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")


async def main() -> None:
    # Create the agent with a connector
    agent = await client.beta.agents.create_async(
        name="deepwiki_agent",
        description="Agent with DeepWiki access for code repository exploration",
        model="mistral-small-latest",
        instructions="You are a helpful assistant that can explore code repositories using DeepWiki. Be concise.",
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
            },
        ],
    )

    # Start a conversation using the agent — no tools needed here
    response = await client.beta.conversations.start_async(
        agent_id=agent.id,
        inputs=[
            {"role": "user", "content": "What is the main purpose of the sqlite repository?"}
        ],
    )
    for output in response.outputs:
        if output.type == "message.output":
            print(output.content)


asyncio.run(main())

Attention

Utilisez agent_id au lieu de model lors du démarrage d'une conversation. Vous ne pouvez pas passer les deux.