Mistral Tool Calling

This guide shows how to integrate Seltz as a search tool for Mistral models. When Mistral needs to search for information, it will call your Seltz-powered function and use the results to generate informed responses.

Prerequisites

Mistral API key (Get one here)
Seltz API key (Get one here)

Installation

pip install mistralai seltz

Setup

Set your API keys as environment variables:

export MISTRAL_API_KEY="your-mistral-key"
export SELTZ_API_KEY="your-seltz-key"

Initialize both clients:

from mistralai.client import Mistral
from seltz import Seltz

mistral_client = Mistral()
seltz_client = Seltz()

Define the Search Tool

Create a tool schema that describes the Seltz search function to Mistral:

tools = [
    {
        "type": "function",
        "function": {
            "name": "search",
            "description": "Search for information on the web. Use this tool when you need current information or facts you don't know. Returns relevant documents with URLs and content.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "The search query"
                    },
                    "max_results": {
                        "type": "integer",
                        "description": "Maximum number of results to return (default: 5)"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

Using the Chat API

Here’s a complete example using Mistral’s Chat API with Seltz search:

import json
from mistralai.client import Mistral
from seltz import Seltz

# Initialize clients
mistral_client = Mistral()
seltz_client = Seltz()

# Define the search tool
tools = [
    {
        "type": "function",
        "function": {
            "name": "search",
            "description": "Search for information on the web. Use this tool when you need current information or facts you don't know. Returns relevant documents with URLs and content.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "The search query"
                    },
                    "max_results": {
                        "type": "integer",
                        "description": "Maximum number of results to return (default: 5)"
                    }
                },
                "required": ["query"]
            }
        }
    }
]


def search(query: str, max_results: int = 5) -> str:
    """Execute a Seltz search and return results as JSON."""
    response = seltz_client.search(query, max_results=max_results)
    results = [
        {"url": doc.url, "content": doc.content}
        for doc in response.documents
    ]
    return json.dumps(results)


def chat(user_message: str) -> str:
    """Send a message and handle tool calls."""
    messages = [{"role": "user", "content": user_message}]

    # Initial request
    response = mistral_client.chat.complete(
        model="mistral-large-latest",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )

    assistant_message = response.choices[0].message

    # Check if Mistral wants to use a tool
    if assistant_message.tool_calls:
        # Add assistant message to conversation
        messages.append(assistant_message)

        # Process each tool call
        for tool_call in assistant_message.tool_calls:
            if tool_call.function.name == "search":
                # Parse arguments and execute search
                args = json.loads(tool_call.function.arguments)
                result = search(
                    query=args["query"],
                    max_results=args.get("max_results", 5)
                )

                # Add tool result to conversation
                messages.append({
                    "role": "tool",
                    "name": tool_call.function.name,
                    "content": result,
                    "tool_call_id": tool_call.id
                })

        # Get final response with search results
        final_response = mistral_client.chat.complete(
            model="mistral-large-latest",
            messages=messages,
            tools=tools
        )
        return final_response.choices[0].message.content

    return assistant_message.content


# Example usage
if __name__ == "__main__":
    response = chat("What are the latest developments in quantum computing?")
    print(response)

How It Works

User sends a message - The user asks a question that may require search
Mistral decides to search - The model determines if it needs external information
Tool call is made - Mistral returns a tool call with the search query
Seltz executes search - Your code calls Seltz with the query
Results sent back - Search results are added to the conversation
Final response - Mistral generates a response using the search results

User Question → Mistral → Tool Call → Seltz Search → Results → Mistral → Final Answer

Streaming Responses

Stream the final response for better user experience:

def chat_stream(user_message: str):
    """Send a message with streaming response."""
    messages = [{"role": "user", "content": user_message}]

    # Initial request (non-streaming to check for tool use)
    response = mistral_client.chat.complete(
        model="mistral-large-latest",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )

    assistant_message = response.choices[0].message

    if assistant_message.tool_calls:
        messages.append(assistant_message)

        for tool_call in assistant_message.tool_calls:
            if tool_call.function.name == "search":
                args = json.loads(tool_call.function.arguments)
                result = search(
                    query=args["query"],
                    max_results=args.get("max_results", 5)
                )
                messages.append({
                    "role": "tool",
                    "name": tool_call.function.name,
                    "content": result,
                    "tool_call_id": tool_call.id
                })

        # Stream the final response
        stream = mistral_client.chat.stream(
            model="mistral-large-latest",
            messages=messages,
            tools=tools
        )

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

Multi-Turn Conversations

Maintain conversation history for follow-up questions:

import json

from mistralai.client import Mistral
from seltz import Seltz


class SearchAssistant:
    def __init__(self):
        self.mistral = Mistral()
        self.seltz = Seltz()
        self.messages = []
        self.tools = [
            {
                "type": "function",
                "function": {
                    "name": "search",
                    "description": "Search the web.",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "query": {"type": "string"},
                            "max_results": {"type": "integer"},
                        },
                        "required": ["query"],
                    },
                },
            }
        ]

    def search(self, query: str, max_results: int = 5) -> str:
        response = self.seltz.search(query, max_results=max_results)
        results = [
            {"url": doc.url, "content": doc.content}
            for doc in response.documents
        ]
        return json.dumps(results)

    def chat(self, user_message: str) -> str:
        self.messages.append({"role": "user", "content": user_message})

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

        assistant_message = response.choices[0].message

        if assistant_message.tool_calls:
            self.messages.append(assistant_message)

            for tool_call in assistant_message.tool_calls:
                if tool_call.function.name == "search":
                    args = json.loads(tool_call.function.arguments)
                    result = self.search(
                        query=args["query"],
                        max_results=args.get("max_results", 5)
                    )
                    self.messages.append({
                        "role": "tool",
                        "name": tool_call.function.name,
                        "content": result,
                        "tool_call_id": tool_call.id
                    })

            final_response = self.mistral.chat.complete(
                model="mistral-large-latest",
                messages=self.messages,
                tools=self.tools
            )
            content = final_response.choices[0].message.content
            self.messages.append({"role": "assistant", "content": content})
            return content

        self.messages.append(assistant_message)
        return assistant_message.content


# Usage
assistant = SearchAssistant()
print(assistant.chat("What is quantum computing?"))
print(assistant.chat("Which companies are leading in this field?"))

Available Models

Mistral models that support function calling:

Model	Description
`mistral-large-latest`	Most capable model, best for complex tasks
`mistral-medium-latest`	Balanced performance and cost
`mistral-small-latest`	Fast and cost-effective
`open-mistral-nemo`	Open-weight model with tool support

Error Handling

Handle Seltz errors gracefully so Mistral can respond appropriately:

from seltz import (
    Seltz,
    SeltzError,
    SeltzAuthenticationError,
    SeltzRateLimitError,
    SeltzTimeoutError,
)


def search(query: str, max_results: int = 5) -> str:
    """Execute search with error handling."""
    try:
        response = seltz_client.search(query, max_results=max_results)
        results = [
            {"url": doc.url, "content": doc.content}
            for doc in response.documents
        ]
        return json.dumps(results)
    except SeltzAuthenticationError:
        return json.dumps({"error": "Search authentication failed"})
    except SeltzRateLimitError:
        return json.dumps({"error": "Search rate limit exceeded, try again later"})
    except SeltzTimeoutError:
        return json.dumps({"error": "Search timed out"})
    except SeltzError as e:
        return json.dumps({"error": f"Search failed: {str(e)}"})

Best Practices

Write clear tool descriptions

Mistral uses the description to decide when to use the tool. Be explicit about what information the search provides and when it should be used.

Choose the right model

Use mistral-large-latest for complex queries requiring nuanced understanding. Use smaller models for straightforward searches to reduce latency and cost.

Handle errors gracefully

Return error information as JSON so Mistral can inform the user or suggest alternatives.

Use streaming for better UX

Stream the final response so users see output immediately rather than waiting for the complete response.

Getting Started

Web Tools

Data

Tutorials

Chat

Integrations

SDKs

Mistral Tool Calling

Prerequisites

Installation

Setup

Define the Search Tool

Using the Chat API

How It Works

Streaming Responses

Multi-Turn Conversations

Available Models

Error Handling

Best Practices

Next Steps

OpenAI Tool Calling

Anthropic Tool Calling

​Prerequisites

​Installation

​Setup

​Define the Search Tool

​Using the Chat API

​How It Works

​Streaming Responses

​Multi-Turn Conversations

​Available Models

​Error Handling

​Best Practices

​Next Steps

OpenAI Tool Calling

Anthropic Tool Calling

Prerequisites

Installation

Setup

Define the Search Tool

Using the Chat API

How It Works

Streaming Responses

Multi-Turn Conversations

Available Models

Error Handling

Best Practices

Next Steps