.png)
Mistral AI Integration Guide
Integrate Mistral AI with enterprise systems through REST APIs, file uploads, asynchronous batch jobs, embeddings, OCR, and controlled Martini workflows.
Mistral AI integration options at a glance
Mistral AI primarily integrates through REST APIs using JSON over HTTPS and bearer-token API-key authentication. Martini can consume endpoints for chat completions, embeddings, models, OCR, moderation, files, batch processing, and fine-tuning, while handling multipart file uploads where required. For high-volume workloads, Martini can prepare JSONL input, upload it, submit an asynchronous batch job, poll its status, and retrieve the output file. Mistral AI also supports streaming for selected generation operations. A general webhook mechanism was not confirmed, so scheduled polling is the safer approach for asynchronous jobs. Martini can expose controlled APIs that apply validation, security, and business rules before invoking Mistral AI.
| Integration point | Supported by Mistral AI? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Mistral AI exposes REST endpoints for chat and text generation, embeddings, models, files, batch jobs, fine-tuning, OCR, moderation, and other enabled platform capabilities. | Martini can consume the REST APIs, construct JSON or multipart requests, map responses, apply business rules, and expose normalized APIs to downstream applications. |
| Bulk / async / batch APIs | Yes | Asynchronous batch processing accepts multiple requests, commonly through an uploaded JSONL input file, and produces an output file after job completion. | Martini can generate stable request identifiers, upload JSONL, submit batch jobs, poll status, retrieve output, and reconcile results with source items. |
| File / attachment APIs | Yes | The Files API supports file operations for supported use cases such as batch processing and fine-tuning; purposes, formats, and lifecycle rules vary by operation. | Martini can prepare multipart uploads, manage file identifiers, retrieve outputs, and route file-processing errors without embedding credentials in workflow definitions. |
| Streaming responses | Limited | Selected generation endpoints can return incremental responses while the client maintains the HTTP request. | Martini can consume supported streaming responses where the workflow design can process or buffer partial output; endpoint-specific support should be confirmed. |
| Webhooks / outbound callbacks | Not confirmed | A general Mistral AI webhook mechanism was not confirmed for model, batch, or fine-tuning events. | Martini should use scheduled polling for asynchronous jobs. If a specific Mistral capability later documents callbacks, Martini can receive them through an exposed API workflow. |
| Authentication | Yes | Mistral AI uses API keys passed as bearer tokens, with access influenced by workspace, account, billing, permissions, and model availability. | Martini can store keys in Secrets Management and inject them into outbound requests while preventing authorization headers from appearing in logs. |
| SDKs | Yes | Mistral AI provides developer SDKs including Python and TypeScript or JavaScript-oriented tooling. | Martini integrations can generally use the underlying REST API directly. SDK use requires a suitable custom implementation environment and is not assumed to be a native Martini feature. |
How Mistral AI exposes data and business events
Mistral AI REST APIs
Mistral AI's primary integration interface is a REST API using JSON over HTTPS for generation, embeddings, models, files, OCR, moderation, batch processing, and other enabled capabilities. File operations may use multipart form data.
Martini implementation pattern
Martini implementation pattern: create a workflow or API that validates the source request, retrieves the model and capability configuration, sends the bearer-authenticated REST request, validates the response, and maps the result to the target system. Reusable request and response mappings isolate provider-specific details.
Implementation sequence
Mistral AI Batch APIs
Mistral AI supports asynchronous batch processing using multiple requests, commonly represented as newline-delimited JSON uploaded through the Files API. A batch job is submitted and later produces an output file.
Martini implementation pattern
Martini implementation pattern: separate batch submission, status polling, and result processing into coordinated workflows. Store the Mistral batch job identifier with the source run, use stable request identifiers in each JSONL record, and prevent duplicate result updates when polling or processing is retried.
Implementation sequence
Mistral AI Files API
The Files API supports file operations for capabilities such as batch processing and fine-tuning. Supported purposes, formats, size limits, and lifecycle rules depend on the specific operation.
Martini implementation pattern
Martini implementation pattern: receive or retrieve a source document, validate its type and size, upload it using a secure multipart request, and persist the returned file identifier. Downstream workflows can invoke the relevant Mistral capability and clean up or retain files according to governance requirements.
Implementation sequence
Scheduled Mistral AI Job Polling
A general Mistral AI webhook or outbound callback mechanism was not confirmed. Batch and fine-tuning jobs should therefore be monitored by retrieving their status from the relevant API endpoint.
Martini implementation pattern
Martini implementation pattern: a scheduler-triggered workflow loads outstanding job identifiers, checks each status, routes queued and running jobs for later polling, processes successful outputs once, and records failed or cancelled jobs for remediation. If a specific product area later documents callbacks, an exposed Martini API can receive them instead.
Implementation sequence
Common Mistral AI integration patterns
Pattern 1: Expose a controlled Mistral AI generation API
When to use this pattern
Use this pattern when several internal applications need generation or conversational capabilities but should not receive Mistral API keys or implement provider-specific request conventions. Martini centralizes model allowlists, prompt templates, privacy controls, validation, and usage logging.
Integration direction
Example Mapping
| Mistral AI Field | Canonical Field | Target Field |
|---|---|---|
| request.messages | conversation.messages | Mistral chat request messages |
| request.model | model.identifier | Mistral model |
| request.max_tokens | generation.maxTokens | Mistral generation parameter |
| response.choices[0].message.content | generated.text | Normalized API response |
Martini implementation pattern
Expose an authenticated Martini REST API, validate request size and permitted models, remove or mask sensitive data where required, construct the Mistral JSON request, validate the generated response, normalize provider errors, and return a stable contract to consuming applications. Record model, usage, correlation, and outcome metadata without logging secrets.
Martini capabilities used
- APIs
- workflows
- API consumption
- data mapping
- business rules
- error handling
- secrets management
Pattern 2: Process enterprise documents with OCR
When to use this pattern
Use this pattern when documents from a repository or business application must be converted into structured information and routed to operational systems such as Salesforce or ServiceNow.
Integration direction
Example Mapping
| Mistral AI Field | Canonical Field | Target Field |
|---|---|---|
| document.content | source.document | Mistral OCR input |
| ocr.pages[].markdown | extracted.text | Normalized document text |
| ocr.fields.invoiceNumber | document.reference | ServiceNow or operational record reference |
| ocr.fields.total | document.amount | Validated target amount |
Martini implementation pattern
A Martini workflow receives a document reference or file, validates type and size, uploads it when required, invokes the Mistral OCR capability, checks required fields and response structure, applies routing rules, and writes the normalized result. Failed extraction or validation is routed to an exception path rather than being silently written.
Martini capabilities used
- workflow orchestration
- file handling
- API consumption
- data mapping
- validation
- business rules
- error handling
Pattern 3: Run asynchronous batch classification
When to use this pattern
Use this pattern for high-volume classification, summarization, or extraction of Salesforce Cases, ServiceNow Incidents, support tickets, or other source items where synchronous processing is inefficient.
Integration direction
Example Mapping
| Mistral AI Field | Canonical Field | Target Field |
|---|---|---|
| Case.Id | source.identifier | JSONL custom request identifier |
| Case.Subject and Description | classification.input | Mistral batch request |
| batch.output.response | ai.result | Salesforce classification or summary |
| batch.output.status | processing.status | Salesforce processing status |
Martini implementation pattern
Martini extracts eligible source items, creates JSONL requests with stable identifiers, uploads the input file, submits a batch job, and stores the job ID. A scheduled workflow polls status with bounded backoff, retrieves the output file, reconciles every result, validates generated fields, updates the source system idempotently, and records failures for replay.
Martini capabilities used
- scheduled workflows
- file handling
- batch orchestration
- JSON processing
- data mapping
- idempotency
- retry handling
Pattern 4: Build an embeddings synchronization workflow
When to use this pattern
Use this pattern when changed enterprise documents or text content must be transformed into embeddings for semantic search, retrieval, classification, or similarity services.
Integration direction
Example Mapping
| Mistral AI Field | Canonical Field | Target Field |
|---|---|---|
| document.body | text.chunk | Mistral embeddings input |
| document.id | source.identifier | Vector metadata identifier |
| document.modifiedDate | source.version | Vector metadata version |
| embedding.data[].embedding | vector.values | Search or vector-store vector |
Martini implementation pattern
A scheduled or event-driven Martini workflow retrieves changed content, splits and normalizes text, submits segments to the embeddings endpoint, and writes vectors with document identifiers and metadata. It compares source versions to avoid unnecessary reprocessing, validates vector responses, and retries transient failures without duplicating unchanged vectors.
Martini capabilities used
- scheduled workflows
- API consumption
- data transformation
- mapping
- change detection
- error handling
- reusable services
Applications commonly integrated with Mistral AI
Mistral AI can be combined with enterprise applications when organizations need controlled generation, extraction, classification, summarization, or embeddings. These relationships are architecture patterns rather than evidence of native Mistral AI integrations. Martini can orchestrate the application APIs, protect Mistral credentials, transform payloads, and write validated results back to operational systems.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Summarize Cases, classify Leads, extract information from documents, or generate controlled sales-assistance content. | Salesforce → Martini → Mistral AI → Salesforce | A Martini workflow retrieves selected Salesforce data, applies data-minimization and prompt rules, invokes the Mistral REST API, validates the response, and updates the source object or routes exceptions for review. |
| ServiceNow | Summarize Incidents, classify requests, draft knowledge content, or extract structured fields from attachments. | ServiceNow → Martini → Mistral AI → ServiceNow | Martini receives or schedules ServiceNow work, calls Mistral AI for the approved capability, validates structured output, and writes results back with correlation identifiers and retry handling. |
| Microsoft Teams | Provide an internal conversational or document-assistance experience without distributing Mistral API keys to users or client applications. | Microsoft Teams → Martini → Mistral AI → Microsoft Teams | Martini exposes an authenticated REST API for the Teams-facing integration, applies model allowlists and request validation, invokes Mistral AI, and returns a normalized response. |
| SharePoint | Extract, classify, summarize, and embed enterprise documents for search or downstream processing. | SharePoint → Martini → Mistral AI → Search platform | A scheduled Martini workflow retrieves changed documents, uploads content when required, invokes OCR or embeddings, maps results with document metadata, and writes them to the approved search or vector platform. |
| Snowflake | Enrich warehouse data with generated classifications, summaries, or embeddings while keeping orchestration and controls outside the data warehouse. | Snowflake → Martini → Mistral AI → Snowflake | Martini selects eligible rows, batches requests where appropriate, invokes Mistral AI, validates generated results, and updates Snowflake using stable source identifiers and processing status. |
| Jira | Summarize issues, classify tickets, extract release-note information, or route work items based on generated labels. | Jira → Martini → Mistral AI → Jira | Martini retrieves selected Jira issues, applies prompt and privacy policies, calls the relevant Mistral endpoint, validates labels or summaries, and updates Jira idempotently. |
How to build a Mistral AI integration in Martini
Objective
Establish a secure outbound connection to Mistral AI using the REST API and environment-specific credentials.
Instructions in Martini
- Configure the Mistral API base URL and relevant endpoint settings.
- Store the API key in Martini Secrets Management.
- Inject the bearer token at runtime and exclude it from logs.
- Set timeouts and request headers for JSON or multipart requests.
Objective
Select a trigger that matches the workload, such as an inbound API request, source-system event, or scheduled job.
Instructions in Martini
- Use an exposed Martini REST API for synchronous internal requests.
- Use a workflow trigger for application-driven processing where applicable.
- Use the scheduler for batch submission, status polling, and recurring synchronization.
- Do not assume Mistral AI provides general webhook delivery.
Objective
Obtain the source text, document, business object, or pending Mistral job needed for processing.
Instructions in Martini
- Retrieve only the source fields required for the AI operation.
- Validate document type, size, model capability, and required identifiers.
- For batch work, select eligible items and generate stable request identifiers.
- For polling, load stored Mistral job identifiers and source correlations.
Objective
Coordinate Mistral requests, asynchronous job state, and downstream processing in a maintainable workflow.
Instructions in Martini
- Call the relevant REST endpoint or upload a file.
- Separate batch submission, polling, and result processing when useful.
- Route queued, running, successful, failed, and cancelled states explicitly.
- Use bounded backoff and prevent resubmission when a status request fails.
Objective
Transform source payloads into Mistral request structures and normalize generated or extracted results for target systems.
Instructions in Martini
- Map messages, model identifiers, parameters, text segments, or file identifiers.
- Parse JSON responses and usage metadata where provided.
- Validate structured output before writing operational data.
- Record the model identifier, source identifier, and processing timestamp.
Objective
Apply organizational policies before and after invoking Mistral AI.
Instructions in Martini
- Enforce model allowlists and request-size limits.
- Mask or remove sensitive data according to governance requirements.
- Route refusals, malformed output, and low-confidence or incomplete extraction to review.
- Use stable business keys to enforce idempotent updates.
Common Mistral AI data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Models | Identify the language, embedding, moderation, code, OCR, or other model used by a request. | Configuration stores, application services, audit databases, and reporting platforms | Martini can keep model identifiers in environment configuration, validate allowlists, and record the selected model with each result. |
| Chat completions | Represent conversational or instruction-based generation requests and responses, including messages, parameters, and usage data. | Salesforce, ServiceNow, Microsoft Teams, Slack, Jira, and internal applications | Martini maps source prompts and messages into JSON requests, invokes the REST API, validates responses, and routes normalized output. |
| Embeddings | Represent vector outputs generated from text for semantic search, retrieval, classification, and similarity workflows. | Search services, vector-capable stores, Snowflake, Databricks, and knowledge applications | Martini segments and normalizes source text, calls the embeddings endpoint, and writes vectors with source identifiers and metadata. |
| Files | Store uploaded input or output files used by supported batch processing and fine-tuning operations. | Document repositories, file stores, batch workflows, and data platforms | Martini uploads or retrieves files using secure multipart or file API requests and tracks file identifiers and processing status. |
| Batch jobs | Track asynchronous processing of many independent requests and the resulting output file. | Salesforce, ServiceNow, support platforms, data warehouses, and operational databases | Martini submits jobs, stores job identifiers, polls status with bounded backoff, retrieves results, and reconciles stable request identifiers. |
| Fine-tuning jobs | Manage customized model creation using training and validation data where enabled. | Model registries, governance stores, application configuration, and deployment workflows | Martini can orchestrate submission and status polling through REST endpoints, subject to workspace capability and current API support. |
Authentication and security considerations
Bearer-token authentication
Mistral AI direct API access uses API keys passed as bearer tokens. Martini should load environment-specific keys from Secrets Management rather than embedding them in workflows or client applications.
Data protection
- Do not expose API keys in logs, responses, or browser-based applications.
- Minimize and mask personal, confidential, or regulated data before sending prompts or files.
- Restrict model identifiers and capabilities through workflow configuration and business rules.
- Treat uploaded files and generated outputs as potentially sensitive.
Operational considerations for Mistral AI integrations
Reliability and provider limits
Mistral account limits and model-specific quotas can vary by workspace, plan, and model. Use bounded exponential backoff for transient failures and rate-limit responses, while avoiding retries for invalid credentials or malformed requests.
Asynchronous processing
Batch and fine-tuning jobs may run for an extended period. Store job identifiers, poll with a maximum duration, process successful outputs exactly once, and route failed or cancelled jobs for review.
Payload and schema management
- Validate model capabilities, request sizes, file types, and required fields before invocation.
- Support pagination for list operations such as models, files, and jobs where applicable.
- Record model identifiers and usage metadata for traceability and chargeback workflows.
- Maintain regression tests for prompts, response schemas, mappings, and model changes.
- Confirm streaming support per endpoint before designing incremental-response processing.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini separates enterprise application integration from Mistral AI request conventions. Workflows can retrieve source data, invoke REST APIs, upload files, poll jobs, transform responses, and update multiple target systems.
Reusable controls
Teams can centralize authentication, model allowlists, privacy filtering, validation, retries, idempotency, error normalization, and usage logging instead of duplicating these controls across scripts and point-to-point integrations.
Maintainable integration assets
- Expose a stable API façade so internal applications do not manage Mistral credentials.
- Isolate provider-specific mappings and model configuration in reusable workflow assets.
- Use workflow monitoring and structured error paths for operational visibility.
- Extend standard REST orchestration with custom logic only when required.
Frequently asked questions
Mistral AI can be integrated primarily through REST APIs using JSON over HTTPS and bearer-token API keys. Enterprise workflows can call chat, embeddings, OCR, moderation, model, file, batch, and fine-tuning endpoints, while asynchronous work can be managed through job-status polling and output-file retrieval.
Yes. Martini can consume Mistral AI REST APIs, upload supported files, submit and monitor batch jobs, map responses, and expose controlled APIs for internal applications. No native Martini Mistral AI connector is documented in the supplied sources.
No. A dedicated Mistral AI connector is not required. Martini can use Mistral AI's confirmed native REST APIs, file operations, bearer-token authentication, streaming responses where supported, and asynchronous batch endpoints.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Mistral AI. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from Mistral AI, infrastructure providers, or other third-party systems based on subscription, usage, and deployment model.
REST APIs are the primary method for current integrations. Use the Files API for supported uploads, batch APIs for asynchronous high-volume work, and streaming only for endpoints and workflows that require incremental output. A general GraphQL or SOAP API was not confirmed.
A general webhook or outbound callback mechanism was not confirmed. For batch and fine-tuning jobs, the safer design is a scheduled Martini workflow that polls status endpoints, applies retry limits, and retrieves results when processing completes.
Use stable source identifiers, model identifiers, job IDs, and processing timestamps to reconcile requests and results. Scheduled workflows can process changed items, submit batch work, poll outstanding jobs, retrieve output files, and update targets idempotently without reprocessing unchanged data.
Martini can map source payloads to Mistral JSON or multipart requests, validate generated or extracted responses, and transform results for downstream systems. Workflows can distinguish authentication, validation, rate-limit, timeout, provider, job, and parsing failures, using bounded retries for transient conditions and exception paths for non-transient errors.
Related Martini documentation
Workflows
Integrate Mistral AI with Martini
Use Martini to connect Mistral AI capabilities with enterprise applications, data platforms, and controlled internal APIs through secure workflows, reusable mappings, and resilient asynchronous processing.