FastAPI Mistral Ticket Router: Safe GCC Guide

Important Accuracy Note Before You Start

The supplied source material confirms that Mistral AI is a Paris-based AI company and describes it as an OpenAI competitor. It does not provide official API documentation, supported model IDs, Python SDK package details, chat-completion method signatures, structured-output parameters, pricing, regional hosting commitments, or deployment guarantees.

For that reason, this tutorial does not present unverified Mistral SDK code as production-ready fact. Instead, it builds a complete, runnable FastAPI ticket router with a deterministic local classifier and a clearly defined provider boundary. After consulting current official Mistral documentation and completing your own evaluation, replace the local classifier implementation at that boundary with the verified Mistral integration appropriate to your account and approved model.

This is a safer engineering approach than copying an unverified model alias, SDK method, or JSON-mode option into a customer-facing workflow. The rest of the service—input contracts, audit storage, authorization, routing policy, tests, and operational controls—remains useful regardless of which approved AI provider or model you connect later.

What You Will Build

You will build a FastAPI service exposing POST /tickets/classify. A client sends a support ticket with a ticket ID, subject, body, customer tier, and source. The service validates the request, classifies it into a limited taxonomy, applies deterministic escalation rules, records an audit event in SQLite, and returns a typed JSON response.

The working baseline intentionally uses transparent keyword rules rather than pretending that an unverified external model call is available. It is not intended to replace an evaluated LLM. Its purpose is to give your team a safe, testable routing baseline and a precise interface for an eventual Mistral-backed classifier.

This architecture is useful for service desks, customer support teams, internal IT queues, security intake, logistics exceptions, and account-management workflows. It is particularly relevant in GCC organisations adopting AI under programmes such as Saudi Vision 2030 and the UAE National Strategy for Artificial Intelligence: automation should preserve review paths, clear ownership, and auditable decisions when tickets may contain customer, employee, or security-sensitive information.

Prerequisites and Installation

• Python 3.10 or newer.
• Basic familiarity with virtual environments, HTTP APIs, and JSON.
• FastAPI, Uvicorn, Pydantic Settings, and pytest.
• A future Mistral API account only when you are ready to implement the provider adapter from current official documentation.

Create the project and install dependencies:

mkdir fastapi-ticket-router
cd fastapi-ticket-router

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip

cat > requirements.txt <<'EOF'
fastapi>=0.115.0
uvicorn[standard]>=0.30.0
pydantic>=2.8.0
pydantic-settings>=2.4.0
pytest>=8.3.0
EOF

pip install -r requirements.txt
mkdir -p app tests
touch app/__init__.py

Create a local environment file. The application API key protects your own endpoint; it is separate from any future AI-provider credential. Do not commit this file to source control.

cat > .env <<'EOF'
APP_API_KEY=replace-with-a-long-random-secret
DATABASE_PATH=./ticket_router.db
MAX_TICKET_CHARACTERS=12000
EOF

cat > .gitignore <<'EOF'
.venv/
.env
__pycache__/
.pytest_cache/
*.pyc
ticket_router.db
EOF

For production, place secrets in the encrypted secret-management facility approved by your cloud or platform team. Never send an AI-provider API key to browser JavaScript, mobile clients, public repositories, or client-side environment variables.

Step 1: Define Strict Contracts and Configuration

LLM integration should sit behind a deterministic API contract. Downstream systems should receive a finite set of categories, bounded confidence values, and explicit review flags—not arbitrary free-form text. Create app/config.py and app/schemas.py:

cat > app/config.py <<'EOF'
from functools import lru_cache
from pydantic import Field, SecretStr
from pydantic_settings import BaseSettings, SettingsConfigDictclass Settings(BaseSettings):
model_config = SettingsConfigDict(env_file=".env", extra="ignore")
app_api_key: SecretStr
database_path: str = "./ticket_router.db"
max_ticket_characters: int = Field(default=12000, ge=500, le=50000)@lru_cache
def get_settings() -> Settings:
return Settings()
EOFcat > app/schemas.py <<'EOF'
from enum import Enum
from pydantic import BaseModel, Field, field_validatorclass CustomerTier(str, Enum):
free = "free"
standard = "standard"
business = "business"
enterprise = "enterprise"class TicketCategory(str, Enum):
billing = "billing"
account_access = "account_access"
technical_issue = "technical_issue"
security = "security"
sales = "sales"
feature_request = "feature_request"
cancellation = "cancellation"
abuse = "abuse"
other = "other"class Urgency(str, Enum):
low = "low"
normal = "normal"
high = "high"
critical = "critical"class TicketInput(BaseModel):
ticket_id: str = Field(min_length=3, max_length=100, pattern=r"^[A-Za-z0-9_-]+$")
subject: str = Field(min_length=3, max_length=300)
body: str = Field(min_length=10, max_length=12000)
customer_tier: CustomerTier = CustomerTier.standard
source: str = Field(default="api", max_length=50)@field_validator("subject", "body")
@classmethod
def reject_blank_text(cls, value: str) -> str:
value = value.strip()
if not value:
raise ValueError("must not be blank")
return valueclass ClassificationResult(BaseModel):
category: TicketCategory
urgency: Urgency
confidence: float = Field(ge=0.0, le=1.0)
recommended_team: str = Field(min_length=2, max_length=80)
customer_summary: str = Field(min_length=10, max_length=500)
...
Continue Reading
Log in for free to read the rest of this article and access exclusive AI tools.
Log in / Register