Tutorial do Mistral Medium 3: Criação de aplicativos agênticos

O Mistral Medium 3 oferece alto desempenho a um preço significativamente mais baixo do que muitas alternativas. Atualmente, ele está disponível por meio da API Mistral AI, com preço de apenas US$ 0,40 por milhão de tokens de entrada e US$ 2 por milhão de tokens de saída. Esse preço supera o desempenho dos principais concorrentes, como DeepSeek v3seja em sistemas API ou auto-implantados. Em resumo, você pode obter até 90% do desempenho do Claude Sonnet 3.7 em vários benchmarks, enquanto você economiza consideravelmente nos custos.

Neste tutorial, aprenderemos como configurar a API do Mistral e usar o cliente Python para acessar o modelo. Depois disso, usaremos o LangGraph para criar um aplicativo agêntico que usa a pesquisa na Web e a ferramenta Python REPL para gerar respostas.

Imagem do autor

Primeiros passos com o Mistral Medium 3

Nesta seção, aprenderemos como gerar a chave da API, salvá-la como uma variável de ambiente e, em seguida, usar o cliente Python para acessar o Mistral Medium 3 para geração de texto e compreensão de imagem.

1. Geração da chave da API do Mistral AI

Inscreva-se no La Plateforme: Mistral AI e, em seguida, vá para Billing (Cobrança) e carregue o crédito de US$ 5 usando o cartão de crédito/débito. Você só precisa de alguns centavos para esse projeto. Depois disso, vá para a seção Chaves de API para gerar a nova chave de API.

2. Configuração do ambiente

A configuração de uma variável de ambiente no DataLab é simples. Basta você acessar a guia "Environment" (Ambiente), selecionar a opção "Environment Variables" (Variáveis de ambiente) e adicionar uma nova variável chamada "MISTRAL_API_KEY" juntamente com sua chave de API. Depois de salvar as alterações, certifique-se de conectá-lo.

No DataLab, crie a nova célula Python e instale o pacote Python do Mistral AI. 

!pip install -U mistralai 

3. Geração de texto

Antes de escrever qualquer código, é essencial que você localize os nomes dos pontos de extremidade da chave da API do Mistral Medium 3 visitando a página Visão geral dos modelos. Com base na documentação, o ponto de extremidade parece ter o nome mistral-medium-latest.

Fonte: Visão geral dos modelos | Mistral AI Large Language Models

Em seguida, criaremos um cliente Mistral AI usando a chave da API e geraremos uma resposta de streaming para uma consulta do usuário. 

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="" )

A resposta é altamente precisa e basicamente não nos custou nada. 

4. Compreensão da imagem

Para testar os recursos multimodais do modelo, faremos uma captura de tela da página inicial do blog da DataCamp e a forneceremos ao modelo junto com um prompt de usuário.

Fonte: Blog | Artigos sobre ciência de dados | DataCamp

Como o modelo não pode acessar diretamente o arquivo de imagem, precisamos primeiro carregar a imagem e convertê-la em uma string codificada em 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)

Agora, enviaremos a imagem codificada em Base64 juntamente com uma consulta do usuário ao cliente de conclusão de bate-papo do 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="" )

O modelo interpreta a imagem com sucesso e gera uma resposta no estilo de Donald Trump, demonstrando seus recursos de compreensão multimodal. 

Criando um aplicativo de agente com o Mistral Medium 3

Neste projeto, usaremos o Mistral Medium 3 com o LangGraph para criar um aplicativo agêntico. Esse aplicativo usará a API Tavily para pesquisa na Web e o Python REPL para executar o código com base nas solicitações do usuário.

Você é novo no LangGraph? Não tem problema! Siga nosso tutorial do LangGraph e aprenda tudo o que você precisa saber sobre a estrutura.

1. Configuração da API da Tavily

Antes de mergulhar na implementação, precisamos configurar o Tavily AI criando uma conta e gerando uma chave de API. O processo é simples, e você não precisa fornecer detalhes de pagamento ou um cartão de crédito.

Depois que você tiver a chave da API, salve-a como uma variável de ambiente chamada TAVILY_API_KEY, localmente ou na configuração do DataLab, conforme mostrado na seção anterior.

2. Instalando pacotes Python

Em seguida, instalaremos os pacotes Python necessários para que você crie ferramentas e agentes usando o ecossistema LangChain.

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

3. Criação de cliente LLM

Criaremos o cliente ChatMistralAI de grandes modelos de linguagem (LLM) da LangChain especificando o nome do modelo, a temperatura e ativando as respostas de streaming .

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

4. Inicialização de ferramentas

Agora, vamos configurar as ferramentas para o agente. Em vez de criar ferramentas manualmente, podemos usar ferramentas pré-construídas como Tavily Search e Python REPL do ecossistema 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. Configuração de um agente

Com o cliente LLM e as ferramentas prontas, agora podemos criar o agente React usando o 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)

O LangGraph Studio é um ambiente de desenvolvimento visual para a estrutura do LangGraph; siga o guia LangGraph Studio Guide: Installation, Set Up, Use Cases para que você saiba mais sobre ele .

7. Testar o agente 

Vamos testar o agente fazendo a ele uma pergunta sobre notícias 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)

O agente usou a ferramenta Tavily Search para gerar uma resposta sobre notícias de última hora.

Em seguida, vamos testar a ferramenta Python REPL pedindo ao agente que gere e execute 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)

O agente usou o Mistral Medium 3 para geração de código e o Python REPL para execução de código.

Por fim, vamos testar uma consulta que exige que o agente use as duas ferramentas em sequência.

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)

O agente usará o Tavily Search para obter dados sobre o preço do ouro, o Mistral Medium 3 para gerar código para visualização de dados e o Python REPL para executar esse código. O resultado incluirá um gráfico altamente preciso, juntamente com um resumo das ferramentas usadas.

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.

Se você encontrar algum problema ao executar o código, consulte a página Mistral Medium 3 - DataLab para obter orientação adicional.

Você pode usar o ecossistema Haystack para criar um aplicativo de agente que seja mais avançado e fácil de implementar. Siga os tutoriais para saber mais: Tutorial de IA do Haystack: Criando fluxos de trabalho agênticos.

Conclusão

Depois de experimentar a API de IA da Mistral e criar agentes para testar vários aplicativos, um dos aspectos mais notáveis é que não me custou um único dólar, mesmo depois de usar 161.075 tokens. O modelo é acessível, rápido, preciso e incrivelmente fácil de configurar. Ele serve como uma ótima alternativa para outras APIs caras, como o DeepSeek, e oferece funcionalidade comparável.

O cenário da IA está claramente se movendo em direção a modelos menores, mais rápidos, mais precisos e econômicos, o que é uma tendência promissora, especialmente para startups e pequenas e médias empresas (PMEs). Essas organizações geralmente dependem muito dos provedores de LLM e, à medida que esses modelos se tornarem mais acessíveis, elas se beneficiarão muito com margens de lucro mais altas.

Pegue o Desenvolvimento de modelos de linguagem grandes para que você crie seus próprios LLMs usando PyTorch e Hugging Face e as mais recentes técnicas de aprendizagem profunda e PNL.