Easy methods to Create Sensible Multi-Agent Workflows Utilizing the Mistral Brokers API’s Handoffs Characteristic

On this tutorial, we’ll discover learn how to create good, multi-agent workflows utilizing the Mistral Brokers API’s Handoffs characteristic. This lets completely different brokers work collectively by passing duties to one another, enabling advanced issues to be solved in a modular and environment friendly manner. We’ll construct a system the place brokers collaborate to reply inflation-related questions—performing calculations, fetching knowledge on-line, and creating visualizations—to ship clear, correct, and dynamic responses.

Step 1: Organising dependencies

Putting in the libraries

pip set up mistralai pydantic

Loading the Mistral API Key

You may get an API key from https://console.mistral.ai/api-keys

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

Step 2: Agent Stipulations and Setup

Initializing the Agent

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

shopper = Mistral(MISTRAL_API_KEY)

Creating the Customized Operate

The adjust_for_inflation perform calculates how a lot a given amount of cash can be value after accounting for inflation over time. It makes use of the compound method based mostly on the variety of years and the annual inflation price. If the top yr is earlier than the beginning yr, it returns an error. In any other case, it returns the adjusted worth together with the enter particulars. For instance, adjust_for_inflation(1000, 1899, 2025, 10) reveals what ₹1000 from 1899 can be value in 2025 at 10% inflation.

def adjust_for_inflation(quantity: float, start_year: int, end_year: int, annual_inflation_rate: float):
    """
    Calculates inflation-adjusted worth utilizing compound method.
    """
    if end_year < start_year:
        return {"error": "Finish yr have to be larger than or equal to start out yr."}

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

    return {
        "original_amount": quantity,
        "start_year": start_year,
        "end_year": end_year,
        "inflation_rate": annual_inflation_rate,
        "adjusted_value": spherical(adjusted_value, 2)
    }

adjust_for_inflation(1000, 1899, 2025, 10)

Creating Structured Output for Mathematical Reasoning

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

inflation_tool = {
    "kind": "perform",
    "perform": {
        "title": "adjust_for_inflation",
        "description": "Calculate the worth of cash adjusted for inflation over a time interval.",
        "parameters": {
            "kind": "object",
            "properties": {
                "quantity": {
                    "kind": "quantity",
                    "description": "Unique amount of cash"
                },
                "start_year": {
                    "kind": "integer",
                    "description": "The beginning yr for inflation adjustment"
                },
                "end_year": {
                    "kind": "integer",
                    "description": "The ending yr for inflation adjustment"
                },
                "annual_inflation_rate": {
                    "kind": "quantity",
                    "description": "Annual inflation price in p.c"
                }
            },
            "required": ["amount", "start_year", "end_year", "annual_inflation_rate"]
        }
    }
}

Step 3: Creating the Brokers

Defining the completely different brokers

On this setup, we outline a multi-agent system utilizing Mistral Brokers API to deal with inflation-related financial queries. The primary agent (economics-agent) acts as a coordinator that routes duties to specialised brokers. The inflation-agent performs inflation adjustment calculations utilizing a customized perform. If the inflation price is lacking from the question, the websearch-agent fetches it from the web. The calculator-agent handles advanced numerical computations with step-by-step reasoning, whereas the graph-agent makes use of the code interpreter to visualise inflation traits over time. Collectively, these brokers collaborate through handoffs to ship correct, dynamic responses to financial queries.

# Foremost Agent
economics_agent = shopper.beta.brokers.create(
    mannequin="mistral-large-latest",
    title="economics-agent",
    description="Handles financial queries and delegates inflation calculations.",
)

# Inflation Operate Agent
inflation_agent = shopper.beta.brokers.create(
    mannequin="mistral-large-latest",
    title="inflation-agent",
    description="Agent that calculates inflation-adjusted worth utilizing a customized perform.",
    instruments=[inflation_tool],
)

# Internet Search Agent
websearch_agent = shopper.beta.brokers.create(
    mannequin="mistral-large-latest",
    title="websearch-agent",
    description="Agent that may search the web for lacking financial knowledge corresponding to inflation charges.",
    instruments=[{"type": "web_search"}]
)


# Calculator Agent
from pydantic import BaseModel

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

calculator_agent = shopper.beta.brokers.create(
    mannequin="mistral-large-latest",
    title="calculator-agent",
    description="Agent used to make detailed calculations.",
    directions="When doing calculations, clarify step-by-step.",
    completion_args=CompletionArgs(
        response_format=ResponseFormat(
            kind="json_schema",
            json_schema=JSONSchema(
                title="calc_result",
                schema=CalcResult.model_json_schema(),
            )
        )
    )
)

# Graph Agent
graph_agent = shopper.beta.brokers.create(
    mannequin="mistral-large-latest",
    title="graph-agent",
    description="Agent that generates graphs utilizing code interpreter.",
    directions="Use code interpreter to attract inflation traits.",
    instruments=[{"type": "code_interpreter"}]
)

Defining the Handoffs Duties

This configuration defines how brokers delegate duties amongst one another:

The Foremost Agent (economics_agent) serves because the entry level and delegates queries both to the inflation_agent (for inflation calculations) or the websearch_agent (to fetch lacking knowledge like inflation charges).

The inflation_agent, after receiving both the person question or web-fetched knowledge, can additional move duties to the calculator_agent (for detailed math) or graph_agent (to visualise traits).

The websearch_agent can move management to the inflation_agent after retrieving required info, just like the inflation price.

calculator_agent and graph_agent are thought of terminal brokers. Nonetheless, elective mutual handoff is enabled in case one must do follow-up work (e.g., graphing a calculated consequence or vice versa).

# Foremost Agent palms off to inflation_agent and websearch_agent
economics_agent = shopper.beta.brokers.replace(
    agent_id=economics_agent.id,
    handoffs=[inflation_agent.id, websearch_agent.id]
)

# Inflation Agent can delegate to calculator_agent or graph_agent if deeper evaluation or visualization is required
inflation_agent = shopper.beta.brokers.replace(
    agent_id=inflation_agent.id,
    handoffs=[calculator_agent.id, graph_agent.id]
)

# Internet Search Agent can hand off to inflation_agent (after discovering the lacking price)
websearch_agent = shopper.beta.brokers.replace(
    agent_id=websearch_agent.id,
    handoffs=[inflation_agent.id]
)

# Calculator and Graph brokers are terminal--they do not hand off additional
# But when wanted, we might allow them to hand off to one another:
calculator_agent = shopper.beta.brokers.replace(
    agent_id=calculator_agent.id,
    handoffs=[graph_agent.id]  # Non-compulsory
)

graph_agent = shopper.beta.brokers.replace(
    agent_id=graph_agent.id,
    handoffs=[calculator_agent.id]  # Non-compulsory
)

Step 4: Working the Agent

Instance A: What’s the present inflation price in India?

On this instance, the immediate “What’s the present inflation price in India?” is handed to the economics_agent, which is the principle entry level for dealing with financial queries. For the reason that query requires real-time knowledge that isn’t included within the agent’s static information, the economics_agent mechanically palms off the question to the websearch_agent, which is supplied with internet search capabilities.

immediate = "What's the present inflation price in India?"
response = shopper.beta.conversations.begin(
    agent_id=economics_agent.id,
    inputs=immediate
)
print(response.outputs[-1].content material[0].textual content)

Instance B: What’s the inflation-adjusted worth of 5,000 from the yr 2010 to 2023 with an annual inflation price of 6.5%. Clarify calculation steps and plot a graph with knowledge labels

This code block sends the immediate to an economics agent, checks if the agent triggers a particular perform name (adjust_for_inflation), executes that perform domestically with the supplied arguments, after which returns the computed consequence again to the agent. Lastly, it prints the agent’s response, which incorporates the inflation calculation clarification, together with the Python code to plot the pattern.

import json

from mistralai.fashions import FunctionResultEntry

immediate = """What's the inflation-adjusted worth of 5,000 from the yr 2010 to 2023 with annual inflation price of 6.5%. 
Clarify calculation steps and plot a graph with knowledge labels"""

response = shopper.beta.conversations.begin(
    agent_id=economics_agent.id,
    inputs=immediate
)

# Verify for perform name
if response.outputs[-1].kind == "perform.name" and response.outputs[-1].title == "adjust_for_inflation":
    args = json.masses(response.outputs[-1].arguments)

    # Run native perform
    function_result = json.dumps(adjust_for_inflation(**args))

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

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

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

The next code block was returned by the agent to plot the pattern of inflation-adjusted worth 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 proportion to decimal

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

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

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

# Add knowledge labels
for yr, worth in zip(years, adjusted_values):
    plt.textual content(yr, worth, f'${worth:.2f}', ha="proper")

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

# Save the plot as a picture
plt.savefig('inflation_adjusted_value.png')

# Present the plot
plt.present()

Try the Pocket book. All credit score for this analysis goes to the researchers of this challenge. Additionally, be at liberty to comply with us on Twitter and don’t overlook to hitch our 98k+ ML SubReddit and Subscribe to our E-newsletter.

I’m a Civil Engineering Graduate (2022) from Jamia Millia Islamia, New Delhi, and I’ve a eager curiosity in Information Science, particularly Neural Networks and their software in numerous areas.