Tutorial Mistral Medium 3: Construir aplicaciones agenticas

Mistral Medium 3 ofrece un alto rendimiento a un precio significativamente inferior al de muchas alternativas. Actualmente está disponible a través de la API Mistral AI, a un precio de sólo 0,40 $ por millón de tokens de entrada y 2 $ por millón de tokens de salida. Este precio supera al de competidores líderes como DeepSeek v3ya sea en API o en sistemas autodesplegados. En resumen, puedes conseguir hasta un 90% del rendimiento de Claude Sonnet 3.7 en varias pruebas comparativas, ahorrando considerablemente en costes.

En este tutorial, aprenderemos a configurar la API de Mistral y a utilizar el cliente Python para acceder al modelo. Después, utilizaremos LangGraph para construir una aplicación agéntica que utilice la búsqueda web y la herramienta REPL de Python para generar respuestas.

Imagen del autor

Primeros pasos con Mistral Medium 3

En esta sección, aprenderemos a generar la clave API, guardarla como variable de entorno y, a continuación, utilizar el cliente Python para acceder a Mistral Medium 3 para la generación de texto y la comprensión de imágenes.

1. Generar la clave API de Mistral AI

Inscríbete en La Plateforme: Mistral AI y luego ve a Facturación y carga el crédito de 5$ utilizando la tarjeta de crédito/débito. Sólo necesitas unos céntimos para este proyecto. Después, ve a Claves API para generar la nueva clave API.

2. Configurar el entorno

Configurar una variable de entorno en DataLab es sencillo. Sólo tienes que ir a la pestaña "Entorno", seleccionar la opción "Variables de entorno" y añadir una nueva variable llamada "MISTRAL_API_KEY" junto con tu clave API. Después de guardar los cambios, asegúrate de conectarlo.

En DataLab, crea la nueva celda Python e instala el paquete Python Mistral AI. 

!pip install -U mistralai 

3. Generación de texto

Antes de escribir cualquier código, es esencial localizar los nombres de los puntos finales de la clave API de Mistral Medium 3 visitando la página Descripción general de los modelos. Según la documentación, el punto final parece llamarse mistral-medium-latest.

Fuente: Visión general de los modelos | Mistral AI Large Language Models

A continuación, crearemos un cliente Mistral AI utilizando la clave API y generaremos una respuesta en streaming a una consulta del usuario. 

import osfrom mistralai import Mistralapi_key = os.environ["MISTRAL_API_KEY"]model = "mistral-medium-latest"client = Mistral(api_key=api_key)stream_response = client.chat.stream(    model = model,    messages = [        {            "role": "user",            "content": "What is the best course to take from DataCamp?",        },    ])for chunk in stream_response:    print(chunk.data.choices[0].delta.content, end="" )

La respuesta es muy precisa y básicamente no nos costó nada. 

4. Comprensión de la imagen

Para probar las capacidades multimodales del modelo, tomaremos una captura de pantalla de la portada del blog de DataCamp y se la proporcionaremos al modelo junto con una pregunta al usuario.

Fuente: Blog | Artículos de Ciencia de Datos | DataCamp

Como el modelo no puede acceder directamente al archivo de imagen, primero tenemos que cargar la imagen y convertirla en una cadena codificada en Base64.

import base64import requestsdef encode_image(image_path):    """Encode the image to base64."""    try:        with open(image_path, "rb") as image_file:            return base64.b64encode(image_file.read()).decode('utf-8')    except FileNotFoundError:        print(f"Error: The file {image_path} was not found.")        return None    except Exception as e:  # Added general exception handling        print(f"Error: {e}")        return None# Path to your imageimage_path = "datacamp_fp.png"# Getting the base64 stringbase64_image = encode_image(image_path)

Ahora enviaremos la imagen codificada en Base64 junto con una consulta de usuario al cliente de finalización de chat Mistral AI.

# Define the messages for the chatmessages = [    {        "role": "user",        "content": [            {                "type": "text",                "text": "Explain the image in a Donald Trump style."            },            {                "type": "image_url",                "image_url": f"data:image/png;base64,{base64_image}"             }        ]    }]stream_response = client.chat.stream(    model = model,    messages = messages)for chunk in stream_response:    print(chunk.data.choices[0].delta.content, end="" )

El modelo interpreta con éxito la imagen y genera una respuesta al estilo de Donald Trump, demostrando su capacidad de comprensión multimodal. 

Construir una Aplicación Agenética con Mistral Medium 3

En este proyecto, utilizaremos Mistral Medium 3 con LangGraph para construir una aplicación agéntica. Esta aplicación utilizará la API de Tavily para la búsqueda web y el REPL de Python para ejecutar código basado en las indicaciones del usuario.

¿Eres nuevo en LangGraph? No hay problema. Sigue nuestro Tutorial LangGraph y aprende todo lo que necesitas saber sobre el framework.

1. Configurar la API de Tavily

Antes de sumergirnos en la implementación, tenemos que configurar Tavily AI creando una cuenta y generando una clave API. El proceso es sencillo, y no necesitas proporcionar datos de pago ni una tarjeta de crédito.

Una vez que tengas la clave API, guárdala como una variable de entorno llamada TAVILY_API_KEY, ya sea localmente o en tu configuración de DataLab, como se muestra en la sección anterior.

2. Instalar paquetes Python

A continuación, instalaremos los paquetes Python necesarios para crear herramientas y agentes que utilicen el ecosistema LangChain.

%%capture!pip install -U \    mistralai \    langchain langchain-mistralai \    langchain-experimental \    langgraph  \    tavily-python

3. Crear cliente LLM

Crearemos el cliente de grandes modelos lingüísticos (LLM ) de LangChain ChatMistralAI especificando el nombre del modelo, la temperatura y activando las respuestas en streaming .

from langchain_mistralai import ChatMistralAIllm = ChatMistralAI(    model="mistral-medium-latest",       temperature=0.2,                     streaming=True          )

4. Inicializar herramientas

Ahora, configuraremos las herramientas para el agente. En lugar de crear herramientas manualmente, podemos utilizar herramientas preconstruidas como Tavily Search y Python REPL del ecosistema LangChain. 

from langchain_community.tools import TavilySearchResultsfrom langchain_experimental.tools.python.tool import PythonREPLToolsearch_tool = TavilySearchResults(max_results=5, include_answer=True)code_tool   = PythonREPLTool()tools = [search_tool, code_tool]

5. Configurar un Agente

Con el cliente LLM y las herramientas listas, ahora podemos crear el Agente React utilizando LangGraph.

from langgraph.prebuilt import create_react_agentagent = create_react_agent(    model=llm,           tools=tools,      )    ```                 6. Extracting tool namesBefore executing the agent, we will define a Python function to extract the names of the tools used during the agent’s response generation. This function will help us identify which tools were invoked.```pythondef extract_tool_names(conversation: dict) -> list[str]:    """    Given a conversation dict with a 'messages' list (where each message    may be a dict or a Pydantic model), extract all unique tool names    used in any tool call.    """    tool_names = set()    for msg in conversation.get('messages', []):        # 1) Try direct attribute access (for Pydantic models)        calls = []        if hasattr(msg, 'tool_calls'):            calls = getattr(msg, 'tool_calls') or []        # 2) If that fails, the message might be a dict        elif isinstance(msg, dict):            calls = msg.get('tool_calls')            # also check nested in additional_kwargs            if not calls and isinstance(msg.get('additional_kwargs'), dict):                calls = msg['additional_kwargs'].get('tool_calls')        # 3) Finally, check additional_kwargs on objects        else:            ak = getattr(msg, 'additional_kwargs', None)            if isinstance(ak, dict):                calls = ak.get('tool_calls', [])        # Normalize to list        calls = calls or []        # Extract names        for call in calls:            # dict-style tool call            if isinstance(call, dict):                # top-level 'name'                if 'name' in call:                    tool_names.add(call['name'])                # nested under 'function'                elif 'function' in call and isinstance(call['function'], dict):                    fn = call['function']                    if 'name' in fn:                        tool_names.add(fn['name'])    return sorted(tool_names)

LangGraph Studio es un entorno de desarrollo visual para el marco LangGraph; sigue la Guía de LangGraph Studio de: Instalación, configuración, casos de uso para saber más sobre él .

7. Probar el agente 

Pongamos a prueba al agente haciéndole una pregunta sobre noticias de última hora. 

question = "What are the top 5 breaking news stories?"def run_agent(question):    result = agent.invoke(        {            "messages": [                {"role": "user", "content": question}            ]        }    )    tool_name = extract_tool_names(result)    # The LLM’s final answer is always in the last message    raw_answer = result["messages"][-1].content    clean_text = "".join(part for part in raw_answer if isinstance(part, str))    return tool_name, clean_texttool_name, clean_text = run_agent(question)print("Tool used ⫸", tool_name, "\n")print(clean_text)

El agente ha utilizado la herramienta de Búsqueda Tavily para generar una respuesta sobre noticias de última hora.

A continuación, vamos a probar la herramienta Python REPL pidiendo al agente que genere y ejecute código Python.

question = "Write a code to display the stars in a triangle. Please execute the code too."tool_name, clean_text = run_agent(question)print("Tool used ⫸", tool_name, "\n")print(clean_text)

El agente ha utilizado Mistral Medium 3 para la generación de código y Python REPL para la ejecución de código.

Por último, probemos una consulta que requiera que el agente utilice ambas herramientas en secuencia.

question = "Get the latest gold price data for the past 7 days and use it to generate a line plot"tool_name, clean_text = run_agent(question)print("Tool used ⫸", tool_name, "\n")print(clean_text)

El agente utilizará Tavily Search para obtener datos sobre el precio del oro, Mistral Medium 3 para generar código para la visualización de datos, y Python REPL para ejecutar ese código. El resultado incluirá un gráfico muy preciso junto con un resumen de las herramientas utilizadas.

Tool used ⫸ ['Python_REPL', 'tavily_search_results_json'] The code generates a line plot showing the gold price per gram in USD over the last 7 days, with the x-axis representing dates and the y-axis representing the gold price. The plot includes markers for each data point, a title, labeled axes, a grid, and rotated x-axis labels for better readability.

Si tienes algún problema al ejecutar el código, consulta la página Mistral Medio 3 - DataLab para obtener más información.

Puedes utilizar el ecosistema Haystack para crear una aplicación de agente más potente y fácil de implementar. Sigue los tutoriales para saber más: Tutorial de IA de Haystack: Construir flujos de trabajo agénticos.

Conclusión

Tras experimentar con la API Mistral AI y crear agentes para probar diversas aplicaciones, uno de los aspectos más destacables es que no me costó ni un solo dólar, incluso después de utilizar 161.075 tokens. El modelo es asequible, rápido, preciso e increíblemente fácil de configurar. Es una gran alternativa a otras API caras, como DeepSeek, y ofrece una funcionalidad comparable.

El panorama de la IA está evolucionando claramente hacia modelos más pequeños, rápidos, precisos y rentables, lo que constituye una tendencia prometedora, sobre todo para las nuevas empresas y las pequeñas y medianas empresas (PYME). Estas organizaciones suelen depender en gran medida de los proveedores de LLM, y a medida que estos modelos se vuelvan más asequibles, se beneficiarán enormemente de unos mayores márgenes de beneficio.

Toma el Desarrollo de grandes modelos lingüísticos para construir tus propios LLM utilizando PyTorch y Hugging Face y las últimas técnicas de aprendizaje profundo y PNL.