tessl/pypi-mistralai

Python Client SDK for the Mistral AI API with chat completions, embeddings, fine-tuning, and agent capabilities.

—

Pending

Overview

Eval results

Files

Chat Completions

Name: tessl/pypi-mistralai
Author: tessl

Create text completions using Mistral's language models with support for conversations, function calling, streaming responses, and structured outputs. The chat completions API is the core interface for generating AI responses.

Capabilities

Basic Chat Completion

Generate responses for conversational AI applications with support for system prompts, user messages, and assistant responses.

def complete(
    model: str,
    messages: List[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]],
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stream: Optional[bool] = None,
    stop: Optional[Union[str, List[str]]] = None,
    random_seed: Optional[int] = None,
    response_format: Optional[ResponseFormat] = None,
    tools: Optional[List[Tool]] = None,
    tool_choice: Optional[Union[str, ToolChoice]] = None,
    safe_prompt: Optional[bool] = None,
    **kwargs
) -> ChatCompletionResponse:
    """
    Create a chat completion.

    Parameters:
    - model: Model identifier (e.g., "mistral-small-latest", "mistral-large-latest")
    - messages: List of conversation messages
    - temperature: Sampling temperature (0.0 to 1.0)
    - top_p: Nucleus sampling parameter (0.0 to 1.0)
    - max_tokens: Maximum tokens to generate
    - stream: Enable streaming responses
    - stop: Stop sequences for generation
    - random_seed: Seed for reproducible outputs
    - response_format: Format specification for structured outputs
    - tools: Available tools for function calling
    - tool_choice: Tool selection strategy
    - safe_prompt: Enable prompt safety checking

    Returns:
    ChatCompletionResponse with generated content
    """

Streaming Chat Completion

Stream responses in real-time for better user experience with long-form content generation.

def stream(
    model: str,
    messages: List[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]],
    temperature: Optional[float] = None,
    top_p: Optional[float] = None,
    max_tokens: Optional[int] = None,
    stop: Optional[Union[str, List[str]]] = None,
    random_seed: Optional[int] = None,
    tools: Optional[List[Tool]] = None,
    tool_choice: Optional[Union[str, ToolChoice]] = None,
    **kwargs
) -> Iterator[CompletionChunk]:
    """
    Create a streaming chat completion.

    Parameters:
    - model: Model identifier
    - messages: List of conversation messages
    - temperature: Sampling temperature (0.0 to 1.0)
    - top_p: Nucleus sampling parameter (0.0 to 1.0)
    - max_tokens: Maximum tokens to generate
    - stop: Stop sequences for generation
    - random_seed: Seed for reproducible outputs
    - tools: Available tools for function calling
    - tool_choice: Tool selection strategy

    Returns:
    Iterator of CompletionChunk objects with streaming content
    """

Structured Output Parsing

Parse responses into structured formats using Pydantic models for type-safe data extraction.

def parse(
    model: str,
    messages: List[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]],
    response_model: Type[BaseModel],
    temperature: Optional[float] = None,
    max_tokens: Optional[int] = None,
    **kwargs
) -> BaseModel:
    """
    Parse chat completion into structured format.

    Parameters:
    - model: Model identifier
    - messages: List of conversation messages
    - response_model: Pydantic model class for parsing
    - temperature: Sampling temperature
    - max_tokens: Maximum tokens to generate

    Returns:
    Parsed model instance with structured data
    """

async def parse_async(
    model: str,
    messages: List[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]],
    response_model: Type[BaseModel],
    **kwargs
) -> BaseModel:
    """
    Async version of parse method.
    """

def parse_stream(
    model: str,
    messages: List[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]],
    response_model: Type[BaseModel],
    **kwargs
) -> Iterator[BaseModel]:
    """
    Stream parsed structured outputs.
    """

async def parse_stream_async(
    model: str,
    messages: List[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]],
    response_model: Type[BaseModel],
    **kwargs
) -> AsyncIterator[BaseModel]:
    """
    Async stream parsed structured outputs.
    """

Usage Examples

Basic Conversation

from mistralai import Mistral
from mistralai.models import SystemMessage, UserMessage

client = Mistral(api_key="your-api-key")

messages = [
    SystemMessage(content="You are a helpful assistant."),
    UserMessage(content="Explain quantum computing in simple terms.")
]

response = client.chat.complete(
    model="mistral-small-latest",
    messages=messages,
    temperature=0.7,
    max_tokens=500
)

print(response.choices[0].message.content)

Function Calling

from mistralai.models import FunctionTool, Function

# Define a tool
weather_tool = FunctionTool(
    type="function",
    function=Function(
        name="get_weather",
        description="Get current weather for a location",
        parameters={
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City name"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["location"]
        }
    )
)

messages = [
    UserMessage(content="What's the weather like in Paris?")
]

response = client.chat.complete(
    model="mistral-small-latest",
    messages=messages,
    tools=[weather_tool],
    tool_choice="auto"
)

# Handle tool calls in response
if response.choices[0].message.tool_calls:
    for tool_call in response.choices[0].message.tool_calls:
        print(f"Tool: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")

Streaming Response

messages = [
    UserMessage(content="Write a short story about a robot.")
]

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=messages,
    temperature=0.8
)

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

Structured Output

from pydantic import BaseModel
from typing import List

class Recipe(BaseModel):
    name: str
    ingredients: List[str]
    instructions: List[str]
    prep_time_minutes: int

messages = [
    UserMessage(content="Give me a recipe for chocolate chip cookies.")
]

recipe = client.chat.parse(
    model="mistral-small-latest",
    messages=messages,
    response_model=Recipe
)

print(f"Recipe: {recipe.name}")
print(f"Prep time: {recipe.prep_time_minutes} minutes")
print(f"Ingredients: {', '.join(recipe.ingredients)}")

Types

Request Types

class ChatCompletionRequest:
    model: str
    messages: List[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]]
    temperature: Optional[float]
    top_p: Optional[float]
    max_tokens: Optional[int]
    stream: Optional[bool]
    stop: Optional[Union[str, List[str]]]
    random_seed: Optional[int]
    response_format: Optional[ResponseFormat]
    tools: Optional[List[Tool]]
    tool_choice: Optional[Union[str, ToolChoice]]
    safe_prompt: Optional[bool]

class ChatCompletionStreamRequest:
    model: str
    messages: List[Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]]
    temperature: Optional[float]
    top_p: Optional[float]
    max_tokens: Optional[int]
    stop: Optional[Union[str, List[str]]]
    random_seed: Optional[int]
    tools: Optional[List[Tool]]
    tool_choice: Optional[Union[str, ToolChoice]]

Response Types

class ChatCompletionResponse:
    id: str
    object: str
    created: int
    model: str
    choices: List[ChatCompletionChoice]
    usage: Optional[UsageInfo]

class ChatCompletionChoice:
    index: int
    message: AssistantMessage
    finish_reason: Optional[str]  # "stop", "length", "tool_calls", "content_filter"

class CompletionChunk:
    id: str
    object: str
    created: int
    model: str
    choices: List[CompletionResponseStreamChoice]

class CompletionResponseStreamChoice:
    index: int
    delta: DeltaMessage
    finish_reason: Optional[str]

class DeltaMessage:
    role: Optional[str]
    content: Optional[str]
    tool_calls: Optional[List[ToolCall]]

Content Types

class TextChunk:
    type: Literal["text"]
    text: str

class ImageURLChunk:
    type: Literal["image_url"]
    image_url: ImageURL

class ImageURL:
    url: str
    detail: Optional[str]  # "auto", "low", "high"

Tool Types

class ToolCall:
    id: str
    type: str
    function: FunctionCall

class FunctionCall:
    name: str
    arguments: str

class Function:
    name: str
    description: Optional[str]
    parameters: Optional[dict]

Install with Tessl CLI