Mistral AI dans un SaaS B2B : 5 use-cases concrets en TypeScript

// src/lib/ai/mistral.ts
import { Mistral } from "@mistralai/mistralai";
import { env } from "~/env";
 
export const mistral = new Mistral({ apiKey: env.MISTRAL_API_KEY });

import { z } from "zod";
 
const InvoiceSchema = z.object({
  invoiceNumber: z.string(),
  date: z.string(),
  totalHT: z.number(),
  totalTTC: z.number(),
  vatRate: z.number(),
  supplierName: z.string(),
});
 
export async function extractInvoiceFromText(text: string) {
  const response = await mistral.chat.complete({
    model: "mistral-small-latest",
    responseFormat: { type: "json_object" },
    messages: [
      {
        role: "system",
        content:
          "Tu extrais les données structurées de factures françaises. Réponds uniquement en JSON valide.",
      },
      {
        role: "user",
        content: `Extrait ces champs de la facture : invoiceNumber, date (YYYY-MM-DD), totalHT, totalTTC, vatRate, supplierName.
 
Facture :
${text}`,
      },
    ],
  });
 
  const raw = response.choices[0]?.message.content;
  if (typeof raw !== "string") throw new Error("Empty response");
 
  return InvoiceSchema.parse(JSON.parse(raw));
}

// src/server/api/routers/crm.ts
import { mistral } from "~/lib/ai/mistral";
 
summarizeClientHistory: requirePermission("crm:read")
  .input(z.object({ clientId: z.string() }))
  .query(async ({ ctx, input }) => {
    const interactions = await ctx.orgDb.clientInteraction.findMany({
      where: { clientId: input.clientId },
      orderBy: { createdAt: "desc" },
      take: 20,
    });
 
    if (interactions.length === 0) return null;
 
    const transcript = interactions
      .map((i) => `[${i.type}] ${i.createdAt.toISOString()} : ${i.content}`)
      .join("\n");
 
    const response = await mistral.chat.complete({
      model: "mistral-small-latest",
      maxTokens: 200,
      messages: [
        {
          role: "system",
          content:
            "Tu es un assistant CRM. Résume en 3 puces : statut actuel, dernier signal d'achat, prochaine action recommandée.",
        },
        { role: "user", content: transcript },
      ],
    });
 
    return response.choices[0]?.message.content ?? null;
  }),

const Category = z.enum([
  "BUG_REPORT",
  "FEATURE_REQUEST",
  "BILLING",
  "ONBOARDING",
  "CHURN_RISK",
  "OTHER",
]);
 
export async function classifyEmail(subject: string, body: string) {
  const response = await mistral.chat.complete({
    model: "mistral-small-latest",
    responseFormat: { type: "json_object" },
    maxTokens: 50,
    messages: [
      {
        role: "system",
        content: `Tu classifies des emails de support. Réponds en JSON : {"category": "...", "urgent": boolean}.
Catégories valides : BUG_REPORT, FEATURE_REQUEST, BILLING, ONBOARDING, CHURN_RISK, OTHER.`,
      },
      { role: "user", content: `Sujet : ${subject}\n\n${body}` },
    ],
  });
 
  const result = z
    .object({ category: Category, urgent: z.boolean() })
    .parse(JSON.parse(response.choices[0]?.message.content ?? "{}"));
 
  return result;
}

generateProductDescription: requirePermission("catalog:write")
  .input(
    z.object({
      productName: z.string(),
      keyFeatures: z.array(z.string()).min(1).max(5),
      tone: z.enum(["pro", "casual", "premium"]).default("pro"),
    }),
  )
  .mutation(async ({ ctx, input }) => {
    // Freemium guard avant l'appel
    const guard = await checkFreemiumLimit(ctx, "aiGenerations");
    if (!guard.allowed) {
      throw new TRPCError({
        code: "FORBIDDEN",
        message: `Quota IA atteint (${guard.used}/${guard.limit})`,
      });
    }
 
    const response = await mistral.chat.complete({
      model: "mistral-small-latest",
      maxTokens: 250,
      messages: [
        {
          role: "system",
          content: `Tu rédiges des descriptions produit en français, ton ${input.tone}. 80 mots max.`,
        },
        {
          role: "user",
          content: `Produit : ${input.productName}\nCaractéristiques :\n- ${input.keyFeatures.join("\n- ")}`,
        },
      ],
    });
 
    // Incrémenter le compteur APRÈS le succès
    await ctx.db.subscription.update({
      where: { organizationId: ctx.session.user.organizationId },
      data: { aiGenerationsUsed: { increment: 1 } },
    });
 
    return response.choices[0]?.message.content ?? "";
  }),

// 1. À la création d'une ressource, calculer son embedding
export async function indexDocument(id: string, text: string) {
  const response = await mistral.embeddings.create({
    model: "mistral-embed",
    inputs: [text],
  });
 
  const embedding = response.data[0]?.embedding;
  if (!embedding) throw new Error("Embedding failed");
 
  // Stockage avec pgvector
  await db.$executeRaw`
    UPDATE "Document"
    SET embedding = ${embedding}::vector
    WHERE id = ${id}
  `;
}
 
// 2. Au moment de la recherche
export async function semanticSearch(query: string, orgId: string) {
  const queryEmbedding = (
    await mistral.embeddings.create({
      model: "mistral-embed",
      inputs: [query],
    })
  ).data[0]?.embedding;
 
  return db.$queryRaw`
    SELECT id, title, 1 - (embedding <=> ${queryEmbedding}::vector) AS similarity
    FROM "Document"
    WHERE "organizationId" = ${orgId}
    ORDER BY embedding <=> ${queryEmbedding}::vector
    LIMIT 10
  `;
}