How to Create Smart Multi-Agent Workflows Using the Mistral Agents API’s Handoffs Feature

2 5 minutes read

1749474964 How to Create Smart Multi Agent Workflows Using the Mistral Agents.png

In this tutorial, we will explore how to create a multi -agent smart workflow using the Handoffs feature of the Mistral Agents Application Authority. This allows different factors to work together by transferring tasks to each other, which allows solving complex problems in a standard and effective way. We will build a system where agents cooperate to answer questions related to inflation-conduct accounts, bring online data, and create perceptions-to provide clear, accurate and dynamic responses.

Step 1: Preparation of dependencies

Install libraries

pip install mistralai pydantic

Download the Mistral Application Extra Directory key

You can get the API key from https://console.mistral.ai/api- Keys

from getpass import getpass
MISTRAL_API_KEY = getpass('Enter Mistral API Key: ')

Step 2: Basic requirements and preparation

Creating the agent

from mistralai import CompletionArgs, ResponseFormat, JSONSchema
from pydantic import BaseModel
from mistralai import Mistral

client = Mistral(MISTRAL_API_KEY)

Create a custom job

The envid_for_inflation function is calculated how much it deserves a certain amount of money after calculating inflation over time. The compound formula is used based on the number of years and the annual inflation rate. If the final year is before the start of the start, it is a mistake. Otherwise, it restores the modified value with the input details. For example, adjust_for_inflation (1000, 1899, 2025, 10) explains $ 1,000 of 1899 in 2025 with 10 % enlargement.

def adjust_for_inflation(amount: float, start_year: int, end_year: int, annual_inflation_rate: float):
    """
    Calculates inflation-adjusted value using compound formula.
    """
    if end_year < start_year:
        return {"error": "End year must be greater than or equal to start year."}

    years = end_year - start_year
    adjusted_value = amount * ((1 + annual_inflation_rate / 100) ** years)

    return {
        "original_amount": amount,
        "start_year": start_year,
        "end_year": end_year,
        "inflation_rate": annual_inflation_rate,
        "adjusted_value": round(adjusted_value, 2)
    }

adjust_for_inflation(1000, 1899, 2025, 10)

Create an organized output for sports thinking

class CalcResult(BaseModel):
    reasoning: str
    result: str

inflation_tool = {
    "type": "function",
    "function": {
        "name": "adjust_for_inflation",
        "description": "Calculate the value of money adjusted for inflation over a time period.",
        "parameters": {
            "type": "object",
            "properties": {
                "amount": {
                    "type": "number",
                    "description": "Original amount of money"
                },
                "start_year": {
                    "type": "integer",
                    "description": "The starting year for inflation adjustment"
                },
                "end_year": {
                    "type": "integer",
                    "description": "The ending year for inflation adjustment"
                },
                "annual_inflation_rate": {
                    "type": "number",
                    "description": "Annual inflation rate in percent"
                }
            },
            "required": ["amount", "start_year", "end_year", "annual_inflation_rate"]
        }
    }
}

Step 3: Establishing agents

Determine the various factors

In this preparation, we define a multi -agent system using the Mistral factors programming interface to deal with economic inflation intelligence. The main agent (economy Agent) works as a coordinator who directs the tasks of specialized agents. The inflation agent performs inflation adjustment accounts using a custom job. If the inflation rate is missing from the query, the Websearch agent brings it from the Internet. The calculator agent deals with the complex numerical calculations with the logic step by step, while the agent uses the graph, a symbol translator to visualize inflation trends over time. These agents cooperate together through delivery operations to provide accurate and dynamic responses to economic information.

# Main Agent
economics_agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="economics-agent",
    description="Handles economic queries and delegates inflation calculations.",
)

# Inflation Function Agent
inflation_agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="inflation-agent",
    description="Agent that calculates inflation-adjusted value using a custom function.",
    tools=[inflation_tool],
)

# Web Search Agent
websearch_agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="websearch-agent",
    description="Agent that can search the internet for missing economic data such as inflation rates.",
    tools=[{"type": "web_search"}]
)


# Calculator Agent
from pydantic import BaseModel

class CalcResult(BaseModel):
    reasoning: str
    result: str

calculator_agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="calculator-agent",
    description="Agent used to make detailed calculations.",
    instructions="When doing calculations, explain step by step.",
    completion_args=CompletionArgs(
        response_format=ResponseFormat(
            type="json_schema",
            json_schema=JSONSchema(
                name="calc_result",
                schema=CalcResult.model_json_schema(),
            )
        )
    )
)

# Graph Agent
graph_agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="graph-agent",
    description="Agent that generates graphs using code interpreter.",
    instructions="Use code interpreter to draw inflation trends.",
    tools=[{"type": "code_interpreter"}]
)

Determining delivery responsibilities

This configuration determines how the agents delegate each other:

The main agent (Economics_agement) works as an entry point and the informative delegates, either to inflation (for inflation calculations) or websearch_gent (to bring lost data such as inflation rates).

After receiving the user’s inquiries or the data on the web, the most passes to Calculator_AGENT (for detailed mathematics) or Graph_agen (to visualize trends).

Websearch_agement can transfer the control to inflation _Agent after recovering the required information, such as the inflation rate.

Calculator_AGENT and Graph_agent are peripheral factors. However, optional mutual delivery is enabled if one needs to do follow -up (for example, draw a calculated result or vice versa).

# Main Agent hands off to inflation_agent and websearch_agent
economics_agent = client.beta.agents.update(
    agent_id=economics_agent.id,
    handoffs=[inflation_agent.id, websearch_agent.id]
)

# Inflation Agent can delegate to calculator_agent or graph_agent if deeper analysis or visualization is needed
inflation_agent = client.beta.agents.update(
    agent_id=inflation_agent.id,
    handoffs=[calculator_agent.id, graph_agent.id]
)

# Web Search Agent can hand off to inflation_agent (after finding the missing rate)
websearch_agent = client.beta.agents.update(
    agent_id=websearch_agent.id,
    handoffs=[inflation_agent.id]
)

# Calculator and Graph agents are terminal--they don't hand off further
# But if needed, we could let them hand off to each other:
calculator_agent = client.beta.agents.update(
    agent_id=calculator_agent.id,
    handoffs=[graph_agent.id]  # Optional
)

graph_agent = client.beta.agents.update(
    agent_id=graph_agent.id,
    handoffs=[calculator_agent.id]  # Optional
)

Step 4: Operating the agent

Example A: What is the current inflation rate in India?

In this example, the claim “What is the current inflation rate in India?” It is passed to Economics_agement, which is the main entry point for dealing with economic inquiries. Since the question requires data in the actual time that is not included in the fixed knowledge of the agent, the economics_gent automatically puts query to the websearch_agement, which is equipped with the web search capabilities.

prompt = "What is the current inflation rate in India?"
response = client.beta.conversations.start(
    agent_id=economics_agent.id,
    inputs=prompt
)
print(response.outputs[-1].content[0].text)

Example B: What is the modified value of inflation of 5,000 from 2010 to 2023 at an annual inflation rate of 6.5 %. Explain the steps of the account and draw a graph with databases

The code block sends this mentor to the economist, and it is achieved whether the agent leads to a specific function (AdD_for_inflation), and performs this job locally with the provided media, then returns the calculated result to the agent. Finally, the agent’s response, which includes the interpretation of the inflation account, is printed alongside the Python icon to draw the direction.

import json

from mistralai.models import FunctionResultEntry

prompt = """What is the inflation-adjusted value of 5,000 from the year 2010 to 2023 with annual inflation rate of 6.5%. 
Explain calculation steps and plot a graph with data labels"""

response = client.beta.conversations.start(
    agent_id=economics_agent.id,
    inputs=prompt
)

# Check for function call
if response.outputs[-1].type == "function.call" and response.outputs[-1].name == "adjust_for_inflation":
    args = json.loads(response.outputs[-1].arguments)

    # Run local function
    function_result = json.dumps(adjust_for_inflation(**args))

    # Return result to Mistral
    result_entry = FunctionResultEntry(
        tool_call_id=response.outputs[-1].tool_call_id,
        result=function_result
    )

    response = client.beta.conversations.append(
        conversation_id=response.conversation_id,
        inputs=[result_entry]
    )

    print(response.outputs[-1].content)
else:
    print(response.outputs[-1].content)

The following code block is returned by the agent to draw the modified value direction that has been modified over time.

import matplotlib.pyplot as plt
import numpy as np

# Parameters
original_amount = 5000
start_year = 2010
end_year = 2023
inflation_rate = 6.5 / 100  # Convert percentage to decimal

# Calculate the number of years
num_years = end_year - start_year + 1

# Calculate the adjusted value for each year
years = np.arange(start_year, end_year + 1)
adjusted_values = original_amount * (1 + inflation_rate) ** (years - start_year)

# Plot the graph
plt.figure(figsize=(10, 6))
plt.plot(years, adjusted_values, marker="o", linestyle="-", color="b")

# Add data labels
for year, value in zip(years, adjusted_values):
    plt.text(year, value, f'${value:.2f}', ha="right")

# Add titles and labels
plt.title('Inflation-Adjusted Value Over Time')
plt.xlabel('Year')
plt.ylabel('Adjusted Value')

# Save the plot as an image
plt.savefig('inflation_adjusted_value.png')

# Show the plot
plt.show()

verify notebook. All the credit for this research goes to researchers in this project. Also, do not hesitate to follow us twitter And do not forget to join 98k+ ml subreddit And subscribe to Our newsletter.

I am a graduate of civil engineering (2022) from Islamic Melia, New Delhi, and I have a strong interest in data science, especially nervous networks and their application in various fields.