Mistral AI in a B2B SaaS: 5 Concrete TypeScript Use Cases

// 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:
          "You extract structured data from invoices. Respond only with valid JSON.",
      },
      {
        role: "user",
        content: `Extract these fields from the invoice: invoiceNumber, date (YYYY-MM-DD), totalHT, totalTTC, vatRate, supplierName.
 
Invoice:
${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:
            "You are a CRM assistant. Summarize in 3 bullets: current status, latest buying signal, recommended next action.",
        },
        { 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: `You classify support emails. Respond in JSON: {"category": "...", "urgent": boolean}.
Valid categories: BUG_REPORT, FEATURE_REQUEST, BILLING, ONBOARDING, CHURN_RISK, OTHER.`,
      },
      { role: "user", content: `Subject: ${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(["professional", "casual", "premium"]).default("professional"),
    }),
  )
  .mutation(async ({ ctx, input }) => {
    // Freemium guard before the call
    const guard = await checkFreemiumLimit(ctx, "aiGenerations");
    if (!guard.allowed) {
      throw new TRPCError({
        code: "FORBIDDEN",
        message: `AI quota reached (${guard.used}/${guard.limit})`,
      });
    }
 
    const response = await mistral.chat.complete({
      model: "mistral-small-latest",
      maxTokens: 250,
      messages: [
        {
          role: "system",
          content: `You write product descriptions, ${input.tone} tone. 80 words max.`,
        },
        {
          role: "user",
          content: `Product: ${input.productName}\nFeatures:\n- ${input.keyFeatures.join("\n- ")}`,
        },
      ],
    });
 
    // Increment the counter AFTER success
    await ctx.db.subscription.update({
      where: { organizationId: ctx.session.user.organizationId },
      data: { aiGenerationsUsed: { increment: 1 } },
    });
 
    return response.choices[0]?.message.content ?? "";
  }),

// 1. When a resource is created, compute its 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");
 
  // Stored via pgvector
  await db.$executeRaw`
    UPDATE "Document"
    SET embedding = ${embedding}::vector
    WHERE id = ${id}
  `;
}
 
// 2. At search time
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
  `;
}