Skip to main content Accueil Créateurs jeremylongshore tons-of-skills-marketplace mistral-sdk-patterns
mistral-sdk-patterns Apply production-ready Mistral AI SDK patterns for TypeScript and Python.
Use when implementing Mistral integrations, refactoring SDK usage,
or establishing team coding standards for Mistral AI.
Trigger with phrases like "mistral SDK patterns", "mistral best practices",
"mistral code patterns", "idiomatic mistral".
Aller à l'installation Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/jeremylongshore/tons-of-skills-marketplace --skill mistral-sdk-patternsLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Plus depuis ce dépôt langchain-deploy-integration Deploy a LangChain 1.0 / LangGraph 1.0 app to Cloud Run, Vercel, or LangServe correctly — with timeouts sized for chain length, cold-start mitigation, SSE anti-buffering headers, and Secret Manager over .env. Use when prepping a first production deploy, debugging a stream that hangs behind a proxy, or diagnosing p99 latency spikes. Trigger with "langchain deploy", "langchain cloud run", "langchain vercel python", "langchain langserve", or "langchain docker".
langchain-langgraph-agents Build a correct LangGraph 1.0 ReAct agent with create_react_agent — typed tools, error propagation, recursion caps, and stop conditions that actually stop. Use when writing a first tool-calling agent, migrating from AgentExecutor or initialize_agent, or diagnosing an agent that loops on vague prompts. Trigger with "langgraph agent", "create_react_agent", "langgraph tool calling", "AgentExecutor migration", or "agent loop cost".
langchain-langgraph-human-in-loop Build LangGraph 1.0 human-in-the-loop approval flows with interrupt_before /
interrupt_after and Command(resume=...) — JSON-serializable state, clean
resume semantics, and UI wiring for approval decisions. Use when adding an
approval gate before an expensive tool call, wiring a Slack/web UI for agent
approvals, or debugging a graph that crashes on interrupt.
Trigger with "langgraph human in loop", "langgraph interrupt_before",
"langgraph approval flow", "Command resume", "langgraph HITL".
name mistral-sdk-patterns description Apply production-ready Mistral AI SDK patterns for TypeScript and Python.
Use when implementing Mistral integrations, refactoring SDK usage,
or establishing team coding standards for Mistral AI.
Trigger with phrases like "mistral SDK patterns", "mistral best practices",
"mistral code patterns", "idiomatic mistral".
allowed-tools Read, Write, Edit version 1.12.0 license MIT author Jeremy Longshore <jeremy@intentsolutions.io> tags ["saas","mistral","python","typescript"] compatibility Designed for Claude Code
Mistral SDK Patterns
Overview
Production-ready patterns for the Mistral AI SDK. Covers singleton client, retry/backoff, structured output, streaming, function calling, batch embeddings, and async Python — all with proper error handling. SDK is ESM-only for TypeScript (@mistralai/mistralai), sync+async for Python (mistralai).
Prerequisites
@mistralai/mistralai (TypeScript) or mistralai (Python) installedMISTRAL_API_KEY environment variable set
Instructions
Step 1: Singleton Client with Configuration
TypeScript
import { Mistral } from '@mistralai/mistralai' ;
let _client : Mistral | null = null ;
export function getMistralClient (Mistral {
if (!_client) {
const apiKey = process.env .MISTRAL_API_KEY ;
if (!apiKey) throw new Error ('MISTRAL_API_KEY not set' );
_client = new Mistral ({
apiKey,
timeoutMs : 30_000 ,
maxRetries : 3 ,
});
}
return _client;
}
export function resetClient (void {
_client = null ;
}
import os
from mistralai import Mistral
_client = None
def get_client () -> Mistral:
global _client
if _client is None :
api_key = os.environ.get("MISTRAL_API_KEY" )
if not api_key:
raise RuntimeError("MISTRAL_API_KEY not set" )
_client = Mistral(api_key=api_key, timeout_ms=30_000 , max_retries=3 )
return _client
Step 2: Structured Output with JSON Schema import { z } from 'zod' ;
const TicketSchema = z.object ({
category : z.enum (['bug' , 'feature' , 'question' ]),
severity : z.enum (['low' , 'medium' , 'high' , 'critical' ]),
summary : z.string (),
});
type Ticket = z.infer <typeof TicketSchema >;
async function classifyTicket (text : string Promise <Ticket > {
const client = getMistralClient ();
const response = await client.chat .complete ({
model : 'mistral-small-latest' ,
messages : [
{ role : 'system' , content : 'Classify the support ticket.' },
{ role : 'user' , content : text },
],
responseFormat : {
type : 'json_schema' ,
jsonSchema : {
name : 'ticket_classification' ,
schema : {
type : 'object' ,
properties : {
category : { type : 'string' , enum : ['bug' , 'feature' , 'question' ] },
severity : { type : 'string' , enum : ['low' , 'medium' , 'high' , 'critical' ] },
summary : { type : 'string' },
},
required : ['category' , 'severity' , 'summary' ],
},
},
},
});
const raw = JSON .parse (response.choices ?.[0 ]?.message ?.content ?? '{}' );
return TicketSchema .parse (raw);
}
Step 3: Streaming with Accumulated Result interface StreamResult {
content : string ;
finishReason : string ;
}
async function streamWithAccumulation (
messages : Array <{ role: string ; content: string }>,
onChunk : (text: string ) => void ,
): Promise <StreamResult > {
const client = getMistralClient ();
const stream = await client.chat .stream ({
model : 'mistral-small-latest' ,
messages,
});
let content = '' ;
let finishReason = '' ;
for await (const event of stream) {
const delta = event.data ?.choices ?.[0 ];
if (delta?.delta ?.content ) {
content += delta.delta .content ;
onChunk (delta.delta .content );
}
if (delta?.finishReason ) {
finishReason = delta.finishReason ;
}
}
return { content, finishReason };
}
Step 4: Python Async Pattern import asyncio
from mistralai import Mistral
async def process_batch (prompts: list [str ], model: str = "mistral-small-latest" ):
"""Process multiple prompts concurrently with semaphore for rate limiting."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY" ])
semaphore = asyncio.Semaphore(5 )
async def process_one (prompt: str ) -> str :
async with semaphore:
response = await client.chat.complete_async(
model=model,
messages=[{"role" : "user" , "content" : prompt}],
)
return response.choices[0 ].message.content
results = await asyncio.gather(*[process_one(p) for p in prompts])
return results
Step 5: Retry with Exponential Backoff async function withRetry<T>(
fn : () => Promise <T>,
maxRetries = 3 ,
): Promise <T> {
for (let attempt = 0 ; attempt <= maxRetries; attempt++) {
try {
return await fn ();
} catch (error : any ) {
const status = error.status ?? error.statusCode ;
const retryable = status === 429 || status >= 500 ;
if (!retryable || attempt === maxRetries) throw error;
const retryAfter = error.headers ?.get ?.('retry-after' );
const delay = retryAfter
? parseInt (retryAfter) * 1000
: Math .min (1000 * 2 ** attempt, 30_000 );
console .warn (`Attempt ${attempt + 1 } failed (${status} ), retrying in ${delay} ms` );
await new Promise (r =>setTimeout (r, delay));
}
}
throw new Error ('Unreachable' );
}
const response = await withRetry (() =>
client.chat .complete ({
model : 'mistral-large-latest' ,
messages : [{ role : 'user' , content : 'Hello' }],
})
);
Step 6: Token Usage Tracking interface UsageStats {
totalPromptTokens : number ;
totalCompletionTokens : number ;
totalRequests : number ;
costUsd : number ;
}
const PRICING : Record <string , { input : number ; output : number }> = {
'mistral-small-latest' : { input : 0.1 , output : 0.3 },
'mistral-large-latest' : { input : 0.5 , output : 1.5 },
'mistral-embed' : { input : 0.1 , output : 0 },
'codestral-latest' : { input : 0.3 , output : 0.9 },
};
class UsageTracker {
private stats : UsageStats = { totalPromptTokens : 0 , totalCompletionTokens : 0 , totalRequests : 0 , costUsd : 0 };
record (model : string , usage : { promptTokens ?: number ; completionTokens ?: number }): void {
const pt = usage.promptTokens ?? 0 ;
const ct = usage.completionTokens ?? 0 ;
this .stats .totalPromptTokens += pt;
this .stats .totalCompletionTokens += ct;
this .stats .totalRequests ++;
const p = PRICING [model] ?? PRICING ['mistral-small-latest' ];
this .stats .costUsd += (pt / 1e6 ) * p.input + (ct / 1e6 ) * p.output ;
}
report (): UsageStats { return { ...this .stats }; }
}
Error Handling Error Cause Solution 401 UnauthorizedInvalid API key Verify MISTRAL_API_KEY 429 Too Many RequestsRate limit hit Use built-in retry or custom backoff 400 Bad RequestInvalid model or params Check model name and parameter values ERR_REQUIRE_ESMCommonJS import SDK is ESM-only; use import syntax Timeout Large prompt or slow network Increase timeoutMs
Resources
Output
Singleton client pattern for TypeScript and Python
Structured output with JSON Schema validation
Streaming with accumulation
Retry/backoff for resilient API calls
Token usage tracking with cost estimation
