Usa Conectores, herramientas integradas y agentes en conversaciones de Mistral AI

Usa Conectores, herramientas integradas y agentes en conversaciones de Mistral AI.

Estado de la API: Las conversaciones usan client.beta.conversations. Los agentes usan client.beta.agents. Estos son endpoints en beta y pueden cambiar.

---

Requisitos previos

Instalar

# Python
pip install mistralai
# or with uv
uv add mistralai

# TypeScript
pnpm add @mistralai/mistralai

Variables de entorno requeridas

Para completar este recetario, necesitarás una clave de API de Mistral. En Studio, navega a la sección de claves de API y crea una nueva clave de API.

Crea un .env en la raíz de tu proyecto y añade tu clave de API de Mistral:

MISTRAL_API_KEY=your-mistral-api-key

Lo que necesitas antes de empezar

La mayoría de las recetas asumen que ya tienes:

• Un client funcional (consulta la Receta 1)
• Un conector existente para las recetas de conectores personalizados — consulta Crea un agente asesor de bases de datos para un ejemplo completo del ciclo de vida de un conector, o crea uno en Studio

---

Lectura de respuestas de conversación

Cada receta de este recetario usa un pequeño ayudante display_response para imprimir la salida de texto del modelo. La API de Conversaciones devuelve una lista de outputs; cada salida con type == "message.output" contiene la respuesta del modelo. El contenido puede ser una cadena simple o una lista de fragmentos de contenido.

Python:

def display_response(response) -> None:
    for output in response.outputs:
        if output.type == "message.output":
            content = output.content
            if isinstance(content, str):
                print(content)
            else:
                text = "".join(
                    chunk.text if hasattr(chunk, "text") else str(chunk)
                    for chunk in content
                )
                print(text)

TypeScript:

function displayResponse(response: any): void {
  for (const output of response.outputs ?? []) {
    if (output.type === "message.output") {
      const content = output.content;
      if (typeof content === "string") {
        console.log(content);
      } else if (Array.isArray(content)) {
        const text = content
          .map((chunk: any) => chunk.text ?? String(chunk))
          .join("");
        console.log(text);
      }
    }
  }
}

Todas las recetas a continuación hacen referencia a este ayudante. Cópialo en tu proyecto o integra la lógica.

---

Recetas

---

1. Hola mundo — primera conversación

Objetivo: Envía tu primer mensaje y lee la respuesta — sin herramientas, sin conectores.

Cuándo usar:

• Verificar que tu configuración funciona de principio a fin.
• Familiarizarte con la estructura de la respuesta antes de añadir conectores.

Python:

import asyncio
from mistralai 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": "What is the capital of France?"}
        ],
    )
    display_response(response)


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  const response = await client.beta.conversations.start({
    model: "mistral-small-latest",
    inputs: [
      { role: "user", content: "What is the capital of France?" },
    ],
  });
  displayResponse(response);
}

main();

curl:

curl -X POST "https://api.mistral.ai/v1/conversations" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small-latest",
    "inputs": [{"role": "user", "content": "What is the capital of France?"}]
  }'

Ejemplo de salida:

The capital of France is Paris.

Cómo funciona:

• conversations.start / start_async envía un turno de conversación sin estado al modelo.
• La respuesta contiene una lista de outputs. Cada uno con type == "message.output" contiene la respuesta del modelo.
• No se requieren herramientas ni conectores para una conversación básica.

Errores comunes y soluciones:

---

2. Conversación con búsqueda web

Objetivo: Dale al modelo acceso a información web en tiempo real — no se necesita un conector personalizado.

Cuándo usar:

• La pregunta del usuario requiere información actualizada (clima, noticias, eventos actuales).
• Integración rápida sin crear ni gestionar conectores.

Python:

import asyncio
from mistralai 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": "What is the current weather in Paris? Use web search.",
            }
        ],
        tools=[
            {"type": "web_search"},
        ],
    )
    display_response(response)


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  const response = await client.beta.conversations.start({
    model: "mistral-small-latest",
    inputs: [
      {
        role: "user",
        content: "What is the current weather in Paris? Use web search.",
      },
    ],
    tools: [
      { type: "web_search" },
    ],
  });
  displayResponse(response);
}

main();

curl:

curl -X POST "https://api.mistral.ai/v1/conversations" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small-latest",
    "inputs": [{"role": "user", "content": "What is the current weather in Paris?"}],
    "tools": [{"type": "web_search"}]
  }'

Ejemplo de salida:

Based on current web search results, the weather in Paris today is 8°C with partly cloudy skies...

Cómo funciona:

• web_search es un tipo de herramienta integrada — no se requiere la creación de conectores.
• El modelo decide autónomamente si invocar la búsqueda basándose en la consulta.
• Los resultados de la búsqueda se incorporan automáticamente a la respuesta del modelo.

Errores comunes y soluciones:

---

3. Conversación con un conector personalizado

Objetivo: Usa un Conector en una conversación para que el modelo pueda llamar herramientas externas.

Cuándo usar:

• Has registrado un conector (por ejemplo, DeepWiki) y quieres que el modelo use sus herramientas.
• Conectar capacidades específicas del dominio al modelo (búsqueda de código, consulta de documentación, acciones, etc.).

Requisitos previos:

• Un conector existente — consulta Crea un agente asesor de bases de datos para un ejemplo completo del ciclo de vida de un conector, o crea uno en Studio.

Python:

import asyncio
from mistralai 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
            },
        ],
    )
    display_response(response)


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  const response = await client.beta.conversations.start({
    model: "mistral-small-latest",
    inputs: [
      {
        role: "user",
        content:
          "Using deepwiki, tell me about the structure of the sqlite/sqlite repository.",
      },
    ],
    tools: [
      {
        type: "connector",
        connectorId: "my_deepwiki", // name or UUID
      },
    ],
  });
  displayResponse(response);
}

main();

curl:

curl -X POST "https://api.mistral.ai/v1/conversations" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "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"}]
  }'

Ejemplo de salida:

The sqlite/sqlite repository is organized into several key directories:
- src/ — core SQLite source code
- ext/ — extensions
- test/ — test suite
...

Cómo funciona:

• El campo connector_id acepta el nombre o el UUID del conector.
• El modelo descubre las herramientas expuestas por el servidor MCP y decide cuál llamar.
• Las llamadas a herramientas y los resultados se manejan en el lado del servidor — tú solo ves la respuesta final.

Errores comunes y soluciones:

---

4. Combinando múltiples herramientas en una conversación

Objetivo: Dale al modelo acceso a la búsqueda web y a conectores personalizados simultáneamente.

Cuándo usar:

• Quieres que el modelo elija la mejor herramienta para la tarea entre varias opciones.
• Construir un asistente con múltiples capacidades (por ejemplo, buscar en la web + consultar documentos internos).

Requisitos previos:

• Un conector existente.

Python:

import asyncio
from mistralai 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": "What tools do you have access to? List them briefly.",
            }
        ],
        tools=[
            {"type": "web_search"},
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
            },
        ],
    )
    display_response(response)


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  const response = await client.beta.conversations.start({
    model: "mistral-small-latest",
    inputs: [
      {
        role: "user",
        content: "What tools do you have access to? List them briefly.",
      },
    ],
    tools: [
      { type: "web_search" },
      {
        type: "connector",
        connectorId: "my_deepwiki",
      },
    ],
  });
  displayResponse(response);
}

main();

curl:

curl -X POST "https://api.mistral.ai/v1/conversations" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small-latest",
    "inputs": [{"role": "user", "content": "What tools do you have access to? List them briefly."}],
    "tools": [
      {"type": "web_search"},
      {"type": "connector", "connector_id": "my_deepwiki"}
    ]
  }'

Ejemplo de salida:

I have access to the following tools:
1. Web Search — search the internet for real-time information
2. read_wiki_structure — explore repository wiki structure
3. read_wiki_contents — read specific wiki pages
4. ask_question — ask questions about a repository

Cómo funciona:

• El array tools acepta cualquier combinación de herramientas integradas (web_search) y conectores personalizados.
• Cada conector expone su propio conjunto de herramientas MCP; el modelo las ve todas.
• El modelo decide qué herramienta(s) invocar basándose en la pregunta del usuario.

Errores comunes y soluciones:

---

5. Filtrando herramientas de conector — incluir / excluir

Objetivo: Controlar qué herramientas MCP de un conector son visibles para el modelo.

Cuándo usar:

• Un conector expone muchas herramientas, pero solo necesitas un subconjunto.
• Quieres evitar que el modelo llame a una herramienta específica (por ejemplo, una operación de escritura/eliminación).
• Reducir el ruido de las herramientas para mejorar la precisión del modelo.

Requisitos previos:

• Un conector existente y conocimiento de los nombres de las herramientas que expone.

Nota: Usa o bien include o bien exclude, no ambos simultáneamente.

Excluyendo herramientas específicas

Python:

import asyncio
from mistralai 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": "What tools do you have access to? List their names.",
            }
        ],
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
                "tool_configuration": {
                    "exclude": ["read_wiki_structure"],
                },
            },
        ],
    )
    display_response(response)


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  const response = await client.beta.conversations.start({
    model: "mistral-small-latest",
    inputs: [
      {
        role: "user",
        content: "What tools do you have access to? List their names.",
      },
    ],
    tools: [
      {
        type: "connector",
        connectorId: "my_deepwiki",
        toolConfiguration: {
          exclude: ["read_wiki_structure"],
        },
      },
    ],
  });
  displayResponse(response);
}

main();

curl:

curl -X POST "https://api.mistral.ai/v1/conversations" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "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"] }
    }]
  }'

Salida:

I have access to: read_wiki_contents, ask_question

Incluyendo solo herramientas específicas

Python:

import asyncio
from mistralai 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": "What tools do you have access to? List their names.",
            }
        ],
        tools=[
            {
                "type": "connector",
                "connector_id": "my_deepwiki",
                "tool_configuration": {
                    "include": ["ask_question"],
                },
            },
        ],
    )
    display_response(response)


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  const response = await client.beta.conversations.start({
    model: "mistral-small-latest",
    inputs: [
      {
        role: "user",
        content: "What tools do you have access to? List their names.",
      },
    ],
    tools: [
      {
        type: "connector",
        connectorId: "my_deepwiki",
        toolConfiguration: {
          include: ["ask_question"],
        },
      },
    ],
  });
  displayResponse(response);
}

main();

curl:

curl -X POST "https://api.mistral.ai/v1/conversations" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "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"] }
    }]
  }'

Ejemplo de salida:

I have access to: ask_question

Cómo funciona:

• tool_configuration.exclude elimina las herramientas listadas del conector. Todas las demás permanecen disponibles.
• tool_configuration.include permite las herramientas listadas. Todas las demás están ocultas.
• Los nombres de las herramientas deben coincidir exactamente con lo que expone el servidor MCP. Pídele al modelo que liste sus herramientas primero (sin ningún filtro) para descubrir los nombres exactos.

Errores comunes y soluciones:

---

6. Creando un agente con conectores

Objetivo: Crear un agente persistente preconfigurado con conectores e instrucciones personalizadas, luego chatear con él.

Cuándo usar:

• Quieres un agente reutilizable que siempre tenga acceso a herramientas específicas — no es necesario pasar el array tools en cada llamada.
• Construir una característica de producto donde los usuarios interactúan con un asistente especializado.

Requisitos previos:

• Un conector existente.

Python:

import asyncio
from mistralai import Mistral

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


async def main() -> None:
    agent_id: str | None = None
    try:
        # 1. Create the agent
        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",
                },
            ],
        )
        agent_id = agent.id
        print(f"Created agent: {agent.name} ({agent.id})")

        # 2. Start a conversation using the agent
        response = await client.beta.conversations.start_async(
            agent_id=agent.id,
            inputs=[
                {
                    "role": "user",
                    "content": "What is the main purpose of the sqlite repository?",
                }
            ],
        )
        display_response(response)

    finally:
        # 3. Cleanup
        if agent_id:
            await client.beta.agents.delete_async(agent_id=agent_id)
            print(f"Deleted agent: {agent_id}")


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  let agentId: string | undefined;
  try {
    // 1. Create the agent
    const agent = await client.beta.agents.create({
      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",
          connectorId: "my_deepwiki",
        },
      ],
    });
    agentId = agent.id;
    console.log(`Created agent: ${agent.name} (${agent.id})`);

    // 2. Start a conversation using the agent
    const response = await client.beta.conversations.start({
      agentId: agent.id,
      inputs: [
        {
          role: "user",
          content: "What is the main purpose of the sqlite repository?",
        },
      ],
    });
    displayResponse(response);
  } finally {
    // 3. Cleanup
    if (agentId) {
      await client.beta.agents.delete({ agentId });
      console.log(`Deleted agent: ${agentId}`);
    }
  }
}

main();

curl:

# Create agent
curl -X POST "https://api.mistral.ai/v1/agents" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "deepwiki_agent",
    "description": "Agent with DeepWiki access",
    "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 conversation with agent (use the agent ID from the response above)
curl -X POST "https://api.mistral.ai/v1/conversations" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "<agent-id>",
    "inputs": [{"role": "user", "content": "What is the main purpose of the sqlite repository?"}]
  }'

# Delete agent when done
curl -X DELETE "https://api.mistral.ai/v1/agents/<agent-id>" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}"

Ejemplo de salida:

Created agent: deepwiki_agent (b2c3d4e5-6789-01ab-cdef-234567890abc)
SQLite is a self-contained, serverless, zero-configuration SQL database engine...
Deleted agent: b2c3d4e5-6789-01ab-cdef-234567890abc

Cómo funciona:

• Los agentes son configuraciones persistentes: modelo + instrucciones + herramientas.
• Cuando inicias una conversación con agent_id, el modelo, las instrucciones y las herramientas se precargan — no es necesario pasarlos de nuevo.
• El array tools del agente usa el mismo formato que el parámetro tools en las conversaciones.
• Usa agent_id en lugar de model al iniciar una conversación — no ambos.
• Elimina agentes con client.beta.agents.delete / delete_async cuando ya no sean necesarios.

Errores comunes y soluciones:

---

7. Conectores autenticados con OAuth (Gmail)

Objetivo: Usar un conector que requiere autenticación OAuth2, como Gmail.

Cuándo usar:

• Integrar con servicios que requieren tokens OAuth a nivel de usuario (Gmail, Google Drive, Slack, etc.).
• Construir características donde el modelo accede a datos específicos del usuario.

Requisitos previos:

• Un token de acceso OAuth2 válido para el servicio de destino.

Python:

import asyncio
from mistralai import Mistral

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


async def main() -> None:
    google_oauth_token = "your-google-oauth-token"

    response = await client.beta.conversations.start_async(
        model="mistral-small-latest",
        inputs=[
            {
                "role": "user",
                "content": "What's the latest email I received?",
            }
        ],
        tools=[
            {
                "type": "connector",
                "connector_id": "gmail",
                "authorization": {
                    "type": "oauth2-token",
                    "value": google_oauth_token,
                },
            },
        ],
    )
    display_response(response)


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  const googleOauthToken = "your-google-oauth-token";

  const response = await client.beta.conversations.start({
    model: "mistral-small-latest",
    inputs: [
      {
        role: "user",
        content: "What's the latest email I received?",
      },
    ],
    tools: [
      {
        type: "connector",
        connectorId: "gmail",
        authorization: {
          type: "oauth2-token",
          value: googleOauthToken,
        },
      },
    ],
  });
  displayResponse(response);
}

main();

curl:

curl -X POST "https://api.mistral.ai/v1/conversations" \
  -H "Authorization: Bearer ${MISTRAL_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-small-latest",
    "inputs": [{"role": "user", "content": "What is the latest email I received?"}],
    "tools": [{
      "type": "connector",
      "connector_id": "gmail",
      "authorization": {
        "type": "oauth2-token",
        "value": "<your-google-oauth-token>"
      }
    }]
  }'

Ejemplo de salida:

Your latest email is from John Doe with the subject "Q1 Report Review" received at 2:30 PM today...

Cómo funciona:

• El campo authorization se pasa por herramienta, no globalmente — diferentes conectores pueden usar diferentes tokens.
• type: "oauth2-token" le dice al backend que reenvíe el token al servidor MCP.
• El token no es almacenado por Mistral — se usa solo durante la duración de la solicitud.
• Los conectores integrados como gmail están pre-registrados; no necesitas crearlos.

Errores comunes y soluciones:

---

8. Ejemplo completo — crea un conector, chatea y limpia

Objetivo: Flujo de trabajo de principio a fin: crea un conector, úsalo en una conversación y luego limpia.

Cuándo usar:

• Pruebas de integración.
• Conectores efímeros para tareas únicas.
• Plantilla para flujos de trabajo de producción.

Python:

import asyncio
from mistralai import Mistral

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


async def main() -> None:
    connector_id: str | None = None

    try:
        # 1. Create a connector
        connector = await client.beta.connectors.create_async(
            name="ephemeral_deepwiki",
            description="Temporary connector for a one-off task",
            server="https://mcp.deepwiki.com/mcp",
            visibility="private",
        )
        connector_id = str(connector.id)
        print(f"Created connector: {connector.name} ({connector.id})")

        # 2. Use it in a simple conversation
        response = await client.beta.conversations.start_async(
            model="mistral-small-latest",
            inputs=[
                {
                    "role": "user",
                    "content": "Using deepwiki, summarize the sqlite/sqlite repo in one sentence.",
                }
            ],
            tools=[
                {"type": "connector", "connector_id": "ephemeral_deepwiki"},
            ],
        )
        print("\nConversation response:")
        display_response(response)

        # 3. Use it alongside web search
        response = await client.beta.conversations.start_async(
            model="mistral-small-latest",
            inputs=[
                {
                    "role": "user",
                    "content": "Search the web for the latest SQLite release version, then use deepwiki to find where the version number is defined in the sqlite/sqlite repo.",
                }
            ],
            tools=[
                {"type": "web_search"},
                {"type": "connector", "connector_id": "ephemeral_deepwiki"},
            ],
        )
        print("\nMulti-tool response:")
        display_response(response)

    finally:
        # 4. Always clean up
        if connector_id:
            result = await client.beta.connectors.delete_async(
                connector_id=connector_id,
            )
            print(f"\nCleaned up connector: {result.message}")


asyncio.run(main())

TypeScript:

import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: "your-api-key" });

async function main(): Promise<void> {
  let connectorId: string | undefined;

  try {
    // 1. Create a connector
    const connector = await client.beta.connectors.create({
      name: "ephemeral_deepwiki",
      description: "Temporary connector for a one-off task",
      server: "https://mcp.deepwiki.com/mcp",
      visibility: "private",
    });
    connectorId = connector.id;
    console.log(`Created connector: ${connector.name} (${connector.id})`);

    // 2. Use it in a simple conversation
    const response = await client.beta.conversations.start({
      model: "mistral-small-latest",
      inputs: [
        {
          role: "user",
          content:
            "Using deepwiki, summarize the sqlite/sqlite repo in one sentence.",
        },
      ],
      tools: [
        { type: "connector", connectorId: "ephemeral_deepwiki" },
      ],
    });
    console.log("\nConversation response:");
    displayResponse(response);

    // 3. Use it alongside web search
    const multiResponse = await client.beta.conversations.start({
      model: "mistral-small-latest",
      inputs: [
        {
          role: "user",
          content:
            "Search the web for the latest SQLite release version, then use deepwiki to find where the version number is defined in the sqlite/sqlite repo.",
        },
      ],
      tools: [
        { type: "web_search" },
        { type: "connector", connectorId: "ephemeral_deepwiki" },
      ],
    });
    console.log("\nMulti-tool response:");
    displayResponse(multiResponse);
  } finally {
    // 4. Always clean up
    if (connectorId) {
      const result = await client.beta.connectors.delete({ connectorId });
      console.log(`\nCleaned up connector: ${result.message}`);
    }
  }
}

main();

Salida:

Created connector: ephemeral_deepwiki (c3d4e5f6-...)

Conversation response:
SQLite is a self-contained, serverless SQL database engine used worldwide.

Multi-tool response:
The latest SQLite release is 3.45.1. The version number is defined in src/sqlite.h...

Cleaned up connector: Connector deleted successfully

Cómo funciona:

• El patrón try/finally asegura que el conector siempre se elimine, incluso si la conversación falla.
• Esta receta combina CRUD de conectores (demostrado completamente en Crea un agente asesor de bases de datos) con el uso de conversaciones.
• La segunda conversación demuestra cómo el modelo enruta inteligentemente entre la búsqueda web y el conector personalizado dentro de una sola solicitud.

---

Resumen

Este recetario cubrió ocho recetas para usar Conectores, herramientas integradas y agentes en conversaciones de Mistral AI — desde un básico "hola mundo" hasta Conectores autenticados con OAuth y un ejemplo completo del ciclo de vida de creación, chat y limpieza.

Lo que cubre este recetario:

• Iniciar una conversación con la API de Conversaciones
• Añadir búsqueda web a una conversación
• Usar un Conector personalizado en una conversación
• Combinar múltiples herramientas en una conversación
• Filtrar qué herramientas expone un Conector
• Crear un agente con Conectores
• Conectores autenticados con OAuth (Gmail)
• Ciclo de vida completo: crear un Conector, usarlo en una conversación y limpiar

Características de Mistral usadas:

• API de Conversaciones (beta)
• API de Agentes (beta)
• Conectores (beta)
• Herramienta integrada de búsqueda web

Otros servicios:

• DeepWiki — servidor MCP para exploración de repositorios de GitHub
• Gmail — Conector autenticado con OAuth2

Consulta tus Conectores en Studio.