The Problem
Teams building LLM features struggle to move from ad-hoc prompt tweaking to a repeatable quality process. Production failures get noticed but not systematically fixed—there's no shared loop connecting real traffic, human feedback, and prompt versions. Latitude addresses this by combining observability, evaluations, and prompt management into one platform, with a gateway for serving versioned prompts.
What This Does
Latitude is a monorepo with three main applications. apps/gateway is a TypeScript/Express API exposing REST endpoints for projects, datasets, documents, and conversations (see apps/gateway/src/routes/api/v3/). It includes rate limiting (apps/gateway/src/middlewares/rateLimit/), OpenAPI schemas (apps/gateway/src/openApi/schemas/), and handlers for running prompts and logging runs. apps/engine is a Python service (FastAPI-style, see apps/engine/app/main.py) that runs the GEPA prompt optimizer, exposed via RPC (apps/engine/app/rpc/server.py). apps/console is a TypeScript REPL for interacting with the platform.
The README positions the product in stages: start with telemetry SDKs to capture prompts, inputs/outputs, and costs; then use datasets and evals to build regression suites; finally, use the gateway to version and publish prompts. The prompt optimizer (GEPA) in apps/engine searches prompt variations against your eval suite to reduce recurring failures.
How To Use It
Setup: The repo uses npm for TypeScript apps (apps/console/package.json, apps/gateway/package.json) and uv for the Python engine (apps/engine/pyproject.toml, apps/engine/uv.lock). A Dockerfile exists for the gateway (apps/gateway/docker/Dockerfile). The README's quick start focuses on the managed cloud product; self-hosted setup steps are referenced but not shown in the excerpt.
Configuration: Copy .env.example to .env for environment variables. The gateway's auth middleware (apps/gateway/src/middlewares/auth.ts) and rate limiter expect API keys and Redis configuration. The Python engine reads apps/engine/app/env/env.py.
Running it: The README doesn't give explicit local run commands in the excerpt. The gateway's entry point is apps/gateway/src/routes.ts (Express app), and the engine's is apps/engine/app/main.py. A docker-compose file is not present; you'd likely run each app separately:
Gateway (from apps/gateway)
npm install npm run dev
Engine (from apps/engine)
uv sync uv run uvicorn app.main:app
Real-World Use
A team with a customer-support chatbot instruments their LLM calls with the telemetry SDK. They create a dataset of real user queries, write an LLM-as-judge eval for response quality, and run an experiment comparing prompt versions. When a new prompt fails the eval, they annotate the failure, cluster similar issues, and run GEPA to search for a better prompt. The winning version is published to the gateway, where production traffic picks it up.
Code Health & Issues
Med – apps/console/package.json declares dependencies without a lockfile, so builds are not reproducible. Low – The repo has 30 test files, mostly for gateway handlers and rate limiting, but the engine (Python) has no visible test files. Low – The Python engine uses uv.lock, which is good, but the TypeScript apps lack lockfiles, so dependency drift is possible. Low – No docker-compose.yml or orchestration file for local development, so running all three apps together requires manual setup. Low – .env.example exists, but the README excerpt doesn't document which variables are required, so new users may struggle with configuration.
The codebase has solid CI (GitHub Actions for lint, typecheck, tests, and deployment) and clear separation of concerns across the three apps. The gateway's route/handler/presenter structure is consistent and testable.
The Bottom Line
Latitude is a well-architected platform for teams that want eval-driven prompt engineering in production. The gateway's REST API and the engine's optimizer are genuinely useful, and the CI setup is professional. It's better suited to teams with existing LLM traffic who want to systematize quality than to solo developers looking for a quick prompt playground. The lack of lockfiles and local orchestration are minor friction points, not blockers.