API Mistral in Python con l'SDK OpenAI
Uno script Python per l'API Mistral può essere eseguito contro questo endpoint compatibile con OpenAI con il pacchetto openai standard: imposta l'URL di base, passa la tua chiave e usa il modello uncensored. Questa guida contiene il codice per chat, streaming, JSON, strumenti e batch.
Aggiornato

La versione breve
Per usare un flusso di lavoro Python dell'API Mistral con questo servizio, non hai bisogno della libreria client ufficiale di Mistral. Questo endpoint usa il formato delle chat completion di OpenAI, quindi il pacchetto openai standard funziona: installalo, imposta la base URL su https://api.mistralapikey.com/v1, passa la tua chiave e usa l'ID del modello uncensored.
Nota necessaria: non è l'API ufficiale Mistral e non è affiliata a Mistral. È un servizio separato con un modello a pesi aperti, gestito da un provider indipendente e ottimizzato per rispondere senza rifiuti di contenuti per l'uso adulto lecito. La pagina sulla chiave API Mistral spiega come le chiavi qui si relazionano ad altri servizi.
pip install openai
from openai import OpenAI
client = OpenAI(base_url="https://api.mistralapikey.com/v1", api_key="YOUR_KEY")
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a haiku about retries."}],
)
print(r.choices[0].message.content)Traduci il codice stile Mistral riga per riga
Se hai codice scritto per il client Python di Mistral, la mappatura è breve. Verifica i nomi esatti contro la documentazione ufficiale del client per la versione installata, poiché le librerie cambiano.
| Client stile Mistral | SDK OpenAI contro questo endpoint |
|---|---|
Mistral(api_key=key) | OpenAI(base_url=URL, api_key=key) |
client.chat.complete(...) | client.chat.completions.create(...) |
client.chat.stream(...) | client.chat.completions.create(..., stream=True) |
model="some-model-name" | model="uncensored" |
res.choices[0].message.content | r.choices[0].message.content (uguale) |
I messaggi restano una lista di dizionari con role e content. La forma della risposta per i campi comuni, inclusi choices, usage e finish_reason, è la stessa, quindi il codice che legge solo quelli non richiede modifiche.
A confronto, il cambiamento appare così:
# before (Mistral-style)
# from mistralai import Mistral
# client = Mistral(api_key=KEY)
# res = client.chat.complete(model="...", messages=msgs)
# after
from openai import OpenAI
client = OpenAI(base_url="https://api.mistralapikey.com/v1", api_key=KEY)
res = client.chat.completions.create(model="uncensored", messages=msgs)
text = res.choices[0].message.contentTieni la chiave fuori dal codice
Leggi la chiave e l'URL dall'ambiente e tienili fuori dal controllo versione.
import os
from openai import OpenAI
client = OpenAI(
base_url=os.environ.get("LLM_BASE_URL", "https://api.mistralapikey.com/v1"),
api_key=os.environ["LLM_API_KEY"],
)
Con una shell: export LLM_API_KEY=.... L'SDK OpenAI legge anche OPENAI_API_KEY e OPENAI_BASE_URL quando non li passi esplicitamente, il che è utile per gli strumenti che creano il client per te, ma è anche una classica fonte di bug "chiave sbagliata" quando un vecchio valore resta nella shell. Quando qualcosa fallisce con 401, stampa quali variabili sono impostate prima di fare qualsiasi altra cosa.
Ottieni una chiave nella pagina della chiave API. I nuovi account possono richiedere $0,50 di credito di prova con un clic. Non serve la carta, è valido per 7 giorni ed è limitato a uno per persona.
Streaming, JSON e strumenti
Lo streaming restituisce i token man mano che vengono generati. Imposta stream=True e itera. I dati di utilizzo arrivano alla fine.
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Explain list comprehensions in 3 sentences."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
La modalità JSON richiede un oggetto JSON valido. Scrivi la parola JSON nel tuo prompt e analizza sempre in modo difensivo.
import json
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Return JSON with keys name and tags for a blog post about retries."}],
response_format={"type": "json_object"},
)
data = json.loads(r.choices[0].message.content)
La chiamata di funzioni usa i parametri tools e tool_choice. Quando il modello restituisce tool_calls, esegui la funzione e invia il risultato di nuovo come messaggio con role: "tool" e il matching tool_call_id.
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Weather in Oslo?"}],
tools=tools,
)
print(r.choices[0].message.tool_calls)Chiamate asincrone e parallele
Per i batch, usa il client asincrono. Mantieni il numero di richieste in corso sotto il limite: una chiave completa permette 8 richieste concorrenti e 300 al minuto, una chiave di prova 2 e 60.
import asyncio
from openai import AsyncOpenAI
client = AsyncOpenAI(base_url="https://api.mistralapikey.com/v1", api_key="YOUR_KEY")
sem = asyncio.Semaphore(6)
async def one(prompt):
async with sem:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
max_tokens=200,
)
return r.choices[0].message.content
async def main():
prompts = [f"Give a one-line tip number {i} about Python." for i in range(20)]
results = await asyncio.gather(*(one(p) for p in prompts))
print(len(results))
asyncio.run(main())
Il semaforo di 6 lascia margine sotto 8. Senza di esso, 20 chiamate simultanee colpirebbero HTTP 429 con il codice concurrency. Ricorda che gli streaming tengono il loro slot fino al termine.
Punti critici durante la migrazione
La maggior parte dei problemi deriva da assunzioni ereditate dalla vecchia configurazione piuttosto che dall'endpoint nuovo.
- Nomi di modello hard-coded. Cerca nel codice la vecchia stringa del modello. L'unico ID del modello valido qui è
uncensored, e puoi confermarlo conclient.models.list(). - Prompt scritti per un altro modello. Un modello diverso legge le istruzioni in modo leggermente diverso. Se un prompt di sistema si basava su una formulazione specifica, testalo. Istruzioni brevi e dirette con un esempio del formato di output di solito si trasferiscono meglio.
- Parametri specifici del provider. I parametri che esistono solo nel client di un fornitore possono essere ignorati o rifiutati. Attieniti a quelli standard: temperature, top_p, stop, seed, max_tokens e le penalità vengono trasmesse.
- Flag di tipo safe-mode. Se il tuo vecchio codice attivava un'opzione di moderazione o sicurezza del provider, non c'è un interruttore equivalente qui. Se il tuo prodotto necessita di filtraggio, aggiungilo dal tuo lato prima e dopo la chiamata.
- Stime dei token. Modelli diversi contano i token in modo diverso, quindi alloca il budget dal campo
usageche l'API restituisce, non da un'ipotesi locale.
Pianifica una breve fase di test, non una riscrittura. Prendi dieci prompt dai tuoi log, eseguili con il nuovo client, leggi le risposte e regola il prompt di sistema finché il tono non corrisponde a ciò che vuoi.
Errori e cosa significano
- 401. Chiave errata o mancante, o una chiave di un altro servizio.
- 404. Manca l'URL di base
/v1. - 429 con
rate_limited. Più del limite per minuto. Aspetta e rallenta. - 429 con
concurrency. Troppe richieste contemporaneamente. Abbassa il parallelismo. - 429 con
Retry-After: 5. Sovraccarico temporaneo. Attendi cinque secondi e riprova.
import time
from openai import RateLimitError
def safe(prompt):
for _ in range(4):
try:
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
except RateLimitError:
time.sleep(5)
return None
Salva l'intestazione X-Request-Id dalle chiamate in fallimento. Le richieste fallite o rifiutate non vengono addebitate.
Costi, limiti e cosa non è incluso
La fatturazione è pagamento a consumo: $0,15 per 1M di token di input e $0,50 per 1M di token di output, prepagato, senza abbonamento e senza scadenza. Uno script che invia 1.000 richieste di 1.500 input e 400 token di output costa 1.5M x $0,15 = $0,225 più 0.4M x $0,50 = $0,20, quindi $0,425. Le ricariche vanno da $20 a $500, con un bonus da $50, e la pagina dei prezzi elenca i dettagli.
La finestra di contesto è di 100.000 token, prompt più completamento, e il corpo può essere fino a 8 MB. Il servizio è solo testo: nessuna immagine, audio o video, nessun embedding e nessun fine-tuning, e i contenuti sessuali che coinvolgono minorenni non sono mai permessi. Se vuoi anche la stessa API con altri client, l'articolo sull'API chat compatibile con OpenAI copre le app oltre Python, e la documentazione elenca ogni parametro.
Altre guide
Domande e risposte
Ho bisogno del client Python di Mistral?
No. Il pacchetto standard openai funziona con l'URL di base https://api.mistralapikey.com/v1. Le chiamate in stile Mistral mappano a chat.completions.create.
È l'API ufficiale di Mistral?
No. È un servizio separato con un unico modello a pesi aperti gestito da un provider indipendente, non affiliato a Mistral.
Come evito gli errori 429 nei batch?
Limita le chiamate parallele a meno di 8 con un semaforo, resta sotto le 300 richieste al minuto e attendi dopo una risposta 429.
C'è un modo gratuito per testare?
Sì. Dopo la registrazione puoi richiedere $0,50 di credito di prova nella pagina della chiave API. Non serve la carta ed è valido per 7 giorni.
La tua chiave è a un modulo di distanza
Crea un account, copia la chiave, modifica l'URL di base. È tutta la configurazione.