---
name: mistral-api-referencia
description: Guía completa de integración con la API de Mistral AI (proveedor europeo de LLMs), con ejemplos para chat, streaming, function calling, embeddings y generación de código con Codestral. Opción GDPR-compliant con residencia de datos en la UE.
license: Apache-2.0
metadata:
  id: e44e610d
  slug: mistral-api-referencia
  titulo: "Mistral AI API — Referencia de Integración"
  servicio: IA-Ingenieria-MLOps
  categoria_recurso: IA-Generativa
  tipo: referencia
  nivel: intermedio
  idioma: es
  idioma_original: en
  acceso: gratis
  precio_eur: 0
  plataformas: [Python, Node.js, TypeScript]
  dependencias: [mistralai (Python), @mistralai/mistralai (npm), MISTRAL_API_KEY]
  licencia: { spdx: Apache-2.0, redistribuible: true, uso_comercial: true }
  fuente:
    repo: TerminalSkills/skills
    url: https://github.com/TerminalSkills/skills/tree/main/skills/mistral-api
    commit: 77fa015
    autor: TerminalSkills
    nombre_original: mistral-api
    duplicados_en: []
  seguridad: { veredicto: seguro, riesgo: bajo, escaneado: "2026-06-14", motor: "grep-estatico+auditor-llm" }
  ficha:
    que_hace: "Proporciona ejemplos listos para usar de las principales funcionalidades de la API de Mistral AI: completions, streaming, function calling, JSON mode, embeddings y completado de código FIM con Codestral."
    como_lo_hace: "Mediante snippets de código en Python y TypeScript/Node.js con el SDK oficial de Mistral, cubriendo configuración, modelos disponibles, casos de uso y notas de cumplimiento GDPR."
  content_hash: "e44e610d7895bb7c9091d8a1cc7a84f83dae0152c3a27c8ca668448e50b96555"
  version: 1.0.0
---

# Mistral AI API

## Overview

Mistral AI is a French AI company providing high-quality, cost-efficient language models with EU data residency and GDPR compliance. Their models excel at code generation (Codestral), multilingual tasks, and reasoning. Mistral's API follows OpenAI conventions closely, making integration straightforward.

## Setup

```bash
# Python
pip install mistralai

# TypeScript/Node
npm install @mistralai/mistralai
```

```bash
export MISTRAL_API_KEY=...
```

## Available Models

| Model | Context | Best For |
|---|---|---|
| `mistral-large-latest` | 128k | Most capable, complex reasoning |
| `mistral-small-latest` | 128k | Cost-efficient, everyday tasks |
| `codestral-latest` | 256k | Code generation & completion |
| `mistral-embed` | 8k | Text embeddings |
| `open-mistral-nemo` | 128k | Open-weight, edge deployment |

## Instructions

### Basic Chat Completion (Python)

```python
from mistralai import Mistral

client = Mistral(api_key="your_api_key")  # or reads MISTRAL_API_KEY

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain the difference between async and sync programming."},
    ],
)

print(response.choices[0].message.content)
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")
```

### TypeScript/Node.js

```typescript
import Mistral from "@mistralai/mistralai";

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

const response = await client.chat.complete({
  model: "mistral-large-latest",
  messages: [{ role: "user", content: "Hello from TypeScript!" }],
});

console.log(response.choices[0].message.content);
```

### Streaming

```python
from mistralai import Mistral

client = Mistral()

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[{"role": "user", "content": "Write a haiku about programming."}],
)

for event in stream:
    chunk = event.data.choices[0].delta.content
    if chunk:
        print(chunk, end="", flush=True)
print()
```

### Function Calling

```python
import json
from mistralai import Mistral

client = Mistral()

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_products",
            "description": "Search for products in a catalog",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "max_price": {"type": "number"},
                    "category": {"type": "string"},
                },
                "required": ["query"],
            },
        },
    }
]

messages = [{"role": "user", "content": "Find laptops under $1000"}]

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

if response.choices[0].finish_reason == "tool_calls":
    tool_call = response.choices[0].message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    print(f"Function: {tool_call.function.name}, Args: {args}")

    # Add tool result and continue
    messages.append(response.choices[0].message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps([{"name": "ThinkPad X1", "price": 899}]),
    })

    final = client.chat.complete(model="mistral-large-latest", messages=messages)
    print(final.choices[0].message.content)
```

### JSON Mode

```python
from mistralai import Mistral
import json

client = Mistral()

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": "Return a JSON object with fields: title, author, year for the book '1984'",
        }
    ],
    response_format={"type": "json_object"},
)

data = json.loads(response.choices[0].message.content)
print(data)  # {"title": "1984", "author": "George Orwell", "year": 1949}
```

### Text Embeddings

```python
from mistralai import Mistral

client = Mistral()

response = client.embeddings.create(
    model="mistral-embed",
    inputs=["Machine learning is transforming industries.", "AI is the future of technology."],
)

embeddings = [item.embedding for item in response.data]
print(f"Embedding dimension: {len(embeddings[0])}")  # 1024

# Compute cosine similarity
import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

similarity = cosine_similarity(embeddings[0], embeddings[1])
print(f"Similarity: {similarity:.3f}")
```

### Codestral for Code Completion

```python
from mistralai import Mistral

client = Mistral()

# Fill-in-the-middle (FIM) — Codestral's signature feature
response = client.fim.complete(
    model="codestral-latest",
    prompt="def fibonacci(n):\n    if n <= 1:\n        return n\n    ",
    suffix="\n\nresult = fibonacci(10)\nprint(result)",
)

print(response.choices[0].message.content)
# Returns the middle code that connects prompt to suffix
```

```python
# Standard code generation
response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "user",
            "content": "Write a Python class for a rate limiter using token bucket algorithm.",
        }
    ],
)
print(response.choices[0].message.content)
```

## GDPR Compliance Notes

- All API data processed in EU data centers by default.
- Mistral AI is headquartered in Paris, France — subject to EU/GDPR jurisdiction.
- For enterprise data residency guarantees, use Mistral's Azure or GCP deployments.
- No training on user data by default — check your plan's DPA for details.

## Guidelines

- Use `mistral-large-latest` for complex tasks, `mistral-small-latest` for cost savings.
- Codestral is specialized for code and significantly outperforms general models on FIM tasks.
- The `mistral-embed` model produces 1024-dimensional vectors.
- Mistral models have strong multilingual performance, especially in French, Spanish, Italian, German, and Portuguese.
- Function calling requires `tool_choice` to be set — use `"auto"` for model-driven decisions.
- JSON mode requires the system or user prompt to explicitly mention JSON output.