Skip to content

Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.

Add Mistral provider with schema optimizer and presets

MagellaX5de9b9956737
diff --git a/browser_use/__init__.py b/browser_use/__init__.py
index e67fe8f4e..a219ddc51 100644
--- a/browser_use/__init__.py
+++ b/browser_use/__init__.py
@@ -56,6 +56,7 @@ if TYPE_CHECKING:
from browser_use.llm.azure.chat import ChatAzureOpenAI
from browser_use.llm.google.chat import ChatGoogle
from browser_use.llm.groq.chat import ChatGroq
+ from browser_use.llm.mistral.chat import ChatMistral
from browser_use.llm.ollama.chat import ChatOllama
from browser_use.llm.openai.chat import ChatOpenAI
from browser_use.tools.service import Controller, Tools
@@ -84,6 +85,7 @@ _LAZY_IMPORTS = {
'ChatGoogle': ('browser_use.llm.google.chat', 'ChatGoogle'),
'ChatAnthropic': ('browser_use.llm.anthropic.chat', 'ChatAnthropic'),
'ChatGroq': ('browser_use.llm.groq.chat', 'ChatGroq'),
+ 'ChatMistral': ('browser_use.llm.mistral.chat', 'ChatMistral'),
'ChatAzureOpenAI': ('browser_use.llm.azure.chat', 'ChatAzureOpenAI'),
'ChatOllama': ('browser_use.llm.ollama.chat', 'ChatOllama'),
# LLM models module
@@ -129,6 +131,7 @@ __all__ = [
'ChatGoogle',
'ChatAnthropic',
'ChatGroq',
+ 'ChatMistral',
'ChatAzureOpenAI',
'ChatOllama',
'Tools',
diff --git a/browser_use/llm/README.md b/browser_use/llm/README.md
index fedce4fe6..39feb7421 100644
--- a/browser_use/llm/README.md
+++ b/browser_use/llm/README.md
@@ -8,6 +8,11 @@ We officially support the following LLMs:
- Groq
- Ollama
- DeepSeek
+- Mistral
+
+## Mistral specifics
+
+Use `ChatMistral` with `MISTRAL_API_KEY` (and optional `MISTRAL_BASE_URL`). Structured outputs automatically strip unsupported JSON schema keywords (`minLength`, `maxLength`, `pattern`, `format`), and generation uses `max_tokens` plus the optional `safe_prompt` flag.
## Migrating from LangChain
diff --git a/browser_use/llm/__init__.py b/browser_use/llm/__init__.py
index badaef2eb..38d0d498d 100644
--- a/browser_use/llm/__init__.py
+++ b/browser_use/llm/__init__.py
@@ -33,6 +33,7 @@ if TYPE_CHECKING:
from browser_use.llm.deepseek.chat import ChatDeepSeek
from browser_use.llm.google.chat import ChatGoogle
from browser_use.llm.groq.chat import ChatGroq
+ from browser_use.llm.mistral.chat import ChatMistral
from browser_use.llm.ollama.chat import ChatOllama
from browser_use.llm.openai.chat import ChatOpenAI
from browser_use.llm.openrouter.chat import ChatOpenRouter
@@ -81,6 +82,7 @@ _LAZY_IMPORTS = {
'ChatDeepSeek': ('browser_use.llm.deepseek.chat', 'ChatDeepSeek'),
'ChatGoogle': ('browser_use.llm.google.chat', 'ChatGoogle'),
'ChatGroq': ('browser_use.llm.groq.chat', 'ChatGroq'),
+ 'ChatMistral': ('browser_use.llm.mistral.chat', 'ChatMistral'),
'ChatOllama': ('browser_use.llm.ollama.chat', 'ChatOllama'),
'ChatOpenAI': ('browser_use.llm.openai.chat', 'ChatOpenAI'),
'ChatOpenRouter': ('browser_use.llm.openrouter.chat', 'ChatOpenRouter'),
@@ -140,6 +142,7 @@ __all__ = [
'ChatAnthropicBedrock',
'ChatAWSBedrock',
'ChatGroq',
+ 'ChatMistral',
'ChatAzureOpenAI',
'ChatOllama',
'ChatOpenRouter',
diff --git a/browser_use/llm/mistral/__init__.py b/browser_use/llm/mistral/__init__.py
new file mode 100644
index 000000000..c02dcbb9f
--- /dev/null
+++ b/browser_use/llm/mistral/__init__.py
@@ -0,0 +1,5 @@
+"""Mistral chat model integration."""
+
+from browser_use.llm.mistral.chat import ChatMistral
+
+__all__ = ['ChatMistral']
diff --git a/browser_use/llm/mistral/chat.py b/browser_use/llm/mistral/chat.py
new file mode 100644
index 000000000..751659495
--- /dev/null
+++ b/browser_use/llm/mistral/chat.py
@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any, Mapping, TypeVar, overload
+
+import httpx
+from pydantic import BaseModel
+
+from browser_use.llm.base import BaseChatModel
+from browser_use.llm.exceptions import ModelProviderError, ModelRateLimitError
+from browser_use.llm.messages import BaseMessage
+from browser_use.llm.mistral.schema import MistralSchemaOptimizer
+from browser_use.llm.openai.serializer import OpenAIMessageSerializer
+from browser_use.llm.views import ChatInvokeCompletion, ChatInvokeUsage
+
+logger = logging.getLogger(__name__)
+T = TypeVar('T', bound=BaseModel)
+
+
+@dataclass
+class ChatMistral(BaseChatModel):
+ """Mistral /chat/completions wrapper with schema sanitization."""
+
+ model: str = 'mistral-medium-latest'
+
+ # Generation params
+ temperature: float | None = 0.2
+ top_p: float | None = None
+ max_tokens: int | None = 4096 # Mistral expects max_tokens (not max_completion_tokens)
+ seed: int | None = None
+ safe_prompt: bool = False
+
+ # Client params
+ api_key: str | None = None # Falls back to MISTRAL_API_KEY
+ base_url: str | httpx.URL = 'https://api.mistral.ai/v1'
+ timeout: float | httpx.Timeout | None = None
+ max_retries: int = 5
+ default_headers: Mapping[str, str] | None = None
+ default_query: Mapping[str, object] | None = None
+ http_client: httpx.AsyncClient | None = None
+
+ @property
+ def provider(self) -> str:
+ return 'mistral'
+
+ @property
+ def name(self) -> str:
+ return str(self.model)
+
+ def _get_api_key(self) -> str:
+ key = self.api_key or os.getenv('MISTRAL_API_KEY')
+ if not key:
+ raise ModelProviderError('Missing Mistral API key', status_code=401, model=self.name)
+ return key
+
+ def _get_base_url(self) -> str:
+ return str(os.getenv('MISTRAL_BASE_URL', self.base_url)).rstrip('/')
+
+ def _auth_headers(self) -> dict[str, str]:
+ headers = {
+ 'Authorization': f'Bearer {self._get_api_key()}',
+ 'Content-Type': 'application/json',
+ }
+ if self.default_headers:
+ headers.update(self.default_headers)
+ return headers
+
+ def _client(self) -> httpx.AsyncClient:
+ if self.http_client:
+ return self.http_client
+
+ if not hasattr(self, '_cached_client'):
+ transport = httpx.AsyncHTTPTransport(retries=self.max_retries)
+ self._cached_client = httpx.AsyncClient(timeout=self.timeout, transport=transport)
+ return self._cached_client
+
+ def _serialize_messages(self, messages: list[BaseMessage]) -> list[dict[str, Any]]:
+ raw_messages: list[dict[str, Any]] = []
+ for msg in OpenAIMessageSerializer.serialize_messages(messages):
+ if hasattr(msg, 'model_dump'):
+ raw_messages.append(msg.model_dump(exclude_none=True))
+ else:
+ raw_messages.append(msg) # type: ignore[arg-type]
+ return raw_messages
+
+ def _build_usage(self, usage: dict[str, Any] | None) -> ChatInvokeUsage | None:
+ if not usage:
+ return None
+
+ return ChatInvokeUsage(
+ prompt_tokens=usage.get('prompt_tokens', 0),
+ prompt_cached_tokens=None,
+ prompt_cache_creation_tokens=None,
+ prompt_image_tokens=None,
+ completion_tokens=usage.get('completion_tokens', 0),
+ total_tokens=usage.get('total_tokens', 0),
+ )
+
+ def _extract_content_text(self, choice: dict[str, Any]) -> str:
+ message = choice.get('message', {})
+ content = message.get('content')
+
+ if isinstance(content, list):
+ text_parts = []
+ for part in content:
+ if isinstance(part, dict):
+ if part.get('type') == 'text' and 'text' in part:
+ text_parts.append(part.get('text', ''))
+ elif 'content' in part:
+ text_parts.append(str(part['content']))
+ return ''.join(text_parts)
+
+ if isinstance(content, dict):
+ return json.dumps(content)
+
+ return content or ''
+
+ def _parse_error(self, response: httpx.Response) -> str:
+ try:
+ body = response.json()
+ if isinstance(body, dict):
+ for key in ('message', 'error', 'detail'):
+ val = body.get(key)
+ if isinstance(val, dict):
+ val = val.get('message') or val.get('detail')
+ if val:
+ return str(val)
+ except Exception:
+ pass
+ return response.text
+
+ async def _post(self, payload: dict[str, Any]) -> dict[str, Any]:
+ url = f"{self._get_base_url()}/chat/completions"
+ client = self._client()
+ response = await client.post(url, headers=self._auth_headers(), json=payload, params=self.default_query)
+
+ if response.status_code >= 400:
+ message = self._parse_error(response)
+ if response.status_code == 429:
+ raise ModelRateLimitError(message=message, status_code=response.status_code, model=self.name)
+ raise ModelProviderError(message=message, status_code=response.status_code, model=self.name)
+
+ try:
+ return response.json()
+ except Exception as e:
+ raise ModelProviderError(message=f'Failed to parse Mistral response: {e}', model=self.name) from e
+
+ @overload
+ async def ainvoke(self, messages: list[BaseMessage], output_format: None = None) -> ChatInvokeCompletion[str]: ...
+
+ @overload
+ async def ainvoke(self, messages: list[BaseMessage], output_format: type[T]) -> ChatInvokeCompletion[T]: ...
+
+ async def ainvoke(
+ self, messages: list[BaseMessage], output_format: type[T] | None = None
+ ) -> ChatInvokeCompletion[T] | ChatInvokeCompletion[str]:
+ payload: dict[str, Any] = {
+ 'model': self.model,
+ 'messages': self._serialize_messages(messages),
+ }
+
+ # Generation params
+ if self.temperature is not None:
+ payload['temperature'] = self.temperature
+ if self.top_p is not None:
+ payload['top_p'] = self.top_p
+ if self.max_tokens is not None:
+ payload['max_tokens'] = self.max_tokens
+ if self.seed is not None:
+ payload['seed'] = self.seed
+ if self.safe_prompt:
+ payload['safe_prompt'] = self.safe_prompt
+
+ # Structured output path
+ if output_format is not None:
+ payload['response_format'] = {
+ 'type': 'json_schema',
+ 'json_schema': {
+ 'name': 'agent_output',
+ 'strict': True,
+ 'schema': MistralSchemaOptimizer.create_mistral_compatible_schema(output_format),
+ },
+ }
+
+ try:
+ data = await self._post(payload)
+ choices = data.get('choices', [])
+ if not choices:
+ raise ModelProviderError('Mistral returned no choices', model=self.name)
+
+ content_text = self._extract_content_text(choices[0])
+ usage = self._build_usage(data.get('usage'))
+
+ if output_format is None:
+ return ChatInvokeCompletion(completion=content_text, usage=usage)
+
+ parsed = output_format.model_validate_json(content_text)
+ return ChatInvokeCompletion(completion=parsed, usage=usage)
+
+ except ModelProviderError:
+ raise
+ except ModelRateLimitError:
+ raise
+ except Exception as e:
+ logger.error(f'Mistral invocation failed: {e}')
+ raise ModelProviderError(message=str(e), model=self.name) from e
diff --git a/browser_use/llm/mistral/schema.py b/browser_use/llm/mistral/schema.py
new file mode 100644
index 000000000..e65971c8a
--- /dev/null
+++ b/browser_use/llm/mistral/schema.py
@@ -0,0 +1,36 @@
+"""Schema optimizer for Mistral-compatible JSON schemas."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from browser_use.llm.schema import SchemaOptimizer
+
+
+class MistralSchemaOptimizer:
+ """Create JSON schemas that avoid Mistral's unsupported keywords."""
+
+ UNSUPPORTED_KEYWORDS = {'minLength', 'maxLength', 'pattern', 'format'}
+
+ @classmethod
+ def create_mistral_compatible_schema(cls, model: type[BaseModel]) -> dict[str, Any]:
+ """
+ Build a Mistral-safe schema by starting with the standard optimized schema and
+ then stripping unsupported validation keywords recursively.
+ """
+ base_schema = SchemaOptimizer.create_optimized_json_schema(model)
+ return cls._strip_unsupported_keywords(base_schema)
+
+ @classmethod
+ def _strip_unsupported_keywords(cls, obj: Any) -> Any:
+ if isinstance(obj, dict):
+ return {
+ key: cls._strip_unsupported_keywords(value)
+ for key, value in obj.items()
+ if key not in cls.UNSUPPORTED_KEYWORDS
+ }
+ if isinstance(obj, list):
+ return [cls._strip_unsupported_keywords(item) for item in obj]
+ return obj
diff --git a/browser_use/llm/models.py b/browser_use/llm/models.py
index d09cd4c36..2363d9e32 100644
--- a/browser_use/llm/models.py
+++ b/browser_use/llm/models.py
@@ -15,6 +15,7 @@ from typing import TYPE_CHECKING
from browser_use.llm.azure.chat import ChatAzureOpenAI
from browser_use.llm.google.chat import ChatGoogle
+from browser_use.llm.mistral.chat import ChatMistral
from browser_use.llm.openai.chat import ChatOpenAI
if TYPE_CHECKING:
@@ -52,6 +53,11 @@ google_gemini_2_0_pro: 'BaseChatModel'
google_gemini_2_5_pro: 'BaseChatModel'
google_gemini_2_5_flash: 'BaseChatModel'
google_gemini_2_5_flash_lite: 'BaseChatModel'
+mistral_large: 'BaseChatModel'
+mistral_medium: 'BaseChatModel'
+mistral_small: 'BaseChatModel'
+codestral: 'BaseChatModel'
+pixtral_large: 'BaseChatModel'
def get_llm_by_name(model_name: str):
@@ -70,6 +76,19 @@ def get_llm_by_name(model_name: str):
if not model_name:
raise ValueError('Model name cannot be empty')
+ # Handle top-level Mistral aliases without provider prefix
+ mistral_aliases = {
+ 'mistral_large': 'mistral-large-latest',
+ 'mistral_medium': 'mistral-medium-latest',
+ 'mistral_small': 'mistral-small-latest',
+ 'codestral': 'codestral-latest',
+ 'pixtral_large': 'pixtral-large-latest',
+ }
+ if model_name in mistral_aliases:
+ api_key = os.getenv('MISTRAL_API_KEY')
+ base_url = os.getenv('MISTRAL_BASE_URL', 'https://api.mistral.ai/v1')
+ return ChatMistral(model=mistral_aliases[model_name], api_key=api_key, base_url=base_url)
+
# Parse model name
parts = model_name.split('_', 1)
if len(parts) < 2:
@@ -108,8 +127,22 @@ def get_llm_by_name(model_name: str):
api_key = os.getenv('GOOGLE_API_KEY')
return ChatGoogle(model=model, api_key=api_key)
+ # Mistral Models
+ elif provider == 'mistral':
+ api_key = os.getenv('MISTRAL_API_KEY')
+ base_url = os.getenv('MISTRAL_BASE_URL', 'https://api.mistral.ai/v1')
+ mistral_map = {
+ 'large': 'mistral-large-latest',
+ 'medium': 'mistral-medium-latest',
+ 'small': 'mistral-small-latest',
+ 'codestral': 'codestral-latest',
+ 'pixtral-large': 'pixtral-large-latest',
+ }
+ resolved_model = mistral_map.get(model_part, model.replace('_', '-'))
+ return ChatMistral(model=resolved_model, api_key=api_key, base_url=base_url)
+
else:
- available_providers = ['openai', 'azure', 'google']
+ available_providers = ['openai', 'azure', 'google', 'mistral']
raise ValueError(f"Unknown provider: '{provider}'. Available providers: {', '.join(available_providers)}")
@@ -123,6 +156,8 @@ def __getattr__(name: str) -> 'BaseChatModel':
return ChatAzureOpenAI # type: ignore
elif name == 'ChatGoogle':
return ChatGoogle # type: ignore
+ elif name == 'ChatMistral':
+ return ChatMistral # type: ignore
# Handle model instances - these are the main use case
try:
@@ -135,6 +170,7 @@ __all__ = [
'ChatOpenAI',
'ChatAzureOpenAI',
'ChatGoogle',
+ 'ChatMistral',
'get_llm_by_name',
# OpenAI instances - created on demand
'openai_gpt_4o',
@@ -168,4 +204,10 @@ __all__ = [
'google_gemini_2_5_pro',
'google_gemini_2_5_flash',
'google_gemini_2_5_flash_lite',
+ # Mistral instances - created on demand
+ 'mistral_large',
+ 'mistral_medium',
+ 'mistral_small',
+ 'codestral',
+ 'pixtral_large',
]
diff --git a/browser_use/llm/tests/test_mistral_schema.py b/browser_use/llm/tests/test_mistral_schema.py
new file mode 100644
index 000000000..463c0cfcd
--- /dev/null
+++ b/browser_use/llm/tests/test_mistral_schema.py
@@ -0,0 +1,28 @@
+from pydantic import BaseModel, Field
+
+from browser_use.llm.mistral.schema import MistralSchemaOptimizer
+
+
+class NestedExample(BaseModel):
+ code: str = Field(..., min_length=2, max_length=4, pattern='[A-Z]+')
+ description: str
+
+
+class RootExample(BaseModel):
+ item: NestedExample
+ email: str = Field(..., format='email')
+
+
+def test_mistral_schema_strips_unsupported_keywords():
+ schema = MistralSchemaOptimizer.create_mistral_compatible_schema(RootExample)
+
+ def _assert_no_banned_keys(obj):
+ if isinstance(obj, dict):
+ for key, value in obj.items():
+ assert key not in {'minLength', 'maxLength', 'pattern', 'format'}
+ _assert_no_banned_keys(value)
+ elif isinstance(obj, list):
+ for item in obj:
+ _assert_no_banned_keys(item)
+
+ _assert_no_banned_keys(schema)
diff --git a/examples/models/mistral.py b/examples/models/mistral.py
new file mode 100644
index 000000000..5397e737e
--- /dev/null
+++ b/examples/models/mistral.py
@@ -0,0 +1,28 @@
+"""
+Simple agent run with Mistral.
+
+You need to set MISTRAL_API_KEY in your environment (and optionally MISTRAL_BASE_URL).
+"""
+
+import asyncio
+
+from dotenv import load_dotenv
+
+from browser_use import Agent
+from browser_use.llm.mistral import ChatMistral
+
+load_dotenv()
+
+llm = ChatMistral(model='mistral-medium-latest', temperature=0)
+agent = Agent(
+ llm=llm,
+ task='List two fun weekend activities in Barcelona.',
+)
+
+
+async def main():
+ await agent.run(max_steps=10)
+ input('Press Enter to continue...')
+
+
+asyncio.run(main())