Tech stack

The technology behind every agent.

No black box. This is what MindLab runs on, layer by layer: the models you can choose from, the platform that executes the agents, the vision that runs on your own machine and the infrastructure that keeps it all online.

Book a demo

Models

Three providers with a real adapter in the platform. Each agent picks one, and you can change it from the dashboard without redeploying.

  • OpenAI

    GPT models: the default for most agents, and the engine behind real-time voice.

  • Anthropic

    Claude models for long context and cases that need careful reasoning.

  • Google Gemini

    Gemini for high volume and low latency, plus the open-weight Gemma models.

Voice

Speech-to-speech on the phone, in the widget and in the branch avatar.

  • OpenAI Realtime

    Real-time conversational voice over a persistent WebSocket session.

  • ElevenLabs

    Neural text to speech and streaming transcription.

  • Gemini Live

    The second live-voice engine, used by the avatar.

  • Web Speech API

    The browser's own voice, for deployments that need zero cost per minute.

Computer vision

CP-Vision runs on the customer's own machine: frames are described locally and never leave it.

  • Python

    Language of the vision service.

  • FastAPI

    Its API and the WebSocket that streams descriptions frame by frame.

  • llama.cpp

    Local inference of the vision-language model — no cloud call per frame.

  • MediaPipe

    In-browser perception: people, gestures and face landmarks.

  • ONNX Runtime

    Alternative perception backend, running on the GPU through WebGPU.

Branch avatar

The photorealistic MetaHuman that serves customers on a screen in the branch.

  • Unreal Engine

    Renders the avatar and streams it as video to the browser.

  • WebRTC

    Transport of Pixel Streaming: video, audio and input with no plugin.

  • Three.js

    3D in the browser: the voice orb and the lightweight avatars.

  • Blender

    Preparing and checking the avatar models.

Agent platform

The services that hold the agents, their tools, their memory and every conversation.

  • TypeScript

    Every service is typed end to end, in strict mode.

  • Node.js

    Runtime of the main API.

  • Bun

    Runtime of the RAG service and the MCP servers.

  • NestJS

    Framework of the API: modules, dependency injection and events.

  • Fastify

    HTTP layer underneath, chosen for throughput.

  • Socket.IO

    Live channel of the chat and the voice audio, scaled across instances with Redis.

  • BullMQ

    Asynchronous work: campaigns, indexing, notifications and retries.

  • Model Context Protocol

    How agents reach your systems — our own MCP servers for Shopify, Salesforce, Odoo, Genesys, HubSpot, Google Calendar and more.

Data and knowledge

Conversations, configuration and knowledge bases, isolated per customer.

  • PostgreSQL

    Main database: agents, conversations, tenants and their configuration.

  • Redis

    Cache, queues and the pub/sub that keeps every instance in sync.

  • Qdrant

    Vector store of the knowledge bases: semantic search over your documents.

  • Neo4j

    Knowledge graph: entities and relations for questions a plain search cannot answer.

  • Prisma

    Schema and typed access to the database.

  • LangChain

    Document splitting and the auxiliary chains of the RAG.

Interfaces

The chat widget, the dashboard and this site share one front-end stack.

  • React

    Component model of every interface.

  • Vite

    Build of every front end, including the widget's embeddable bundle.

  • Tailwind CSS

    Design system: utilities and tokens instead of ad-hoc CSS.

Infrastructure

Containers on Kubernetes, described as code, deployed on every merge.

  • AWS

    Where the platform runs: managed Kubernetes, databases, object storage and CDN.

  • Kubernetes

    Orchestration of the backend services.

  • Terraform

    The whole infrastructure as code, reviewable in a pull request.

  • Argo CD

    GitOps: the cluster follows what the repository says it should run.

  • Docker

    Every service ships as a container image.

  • GitHub Actions

    CI/CD: tests, build and deploy, with no static credentials.

  • Cloudflare

    DNS and the edge of this site, including its agent surface.

Observability and quality

What tells us something broke before a customer does.

  • OpenTelemetry

    Distributed traces across services.

  • Grafana

    Dashboards and trace storage.

  • Prometheus

    Service metrics and alerting.

  • Sentry

    Errors in the API and in the interfaces, with their stack trace.

  • Jest

    Test suite of the platform API.

  • Vitest

    Test suite of the front ends.

How we build

Choices we made on purpose

A stack is a set of trade-offs. These are ours, and why.

  • No model lock-in

    Three providers with a real adapter and 48 selectable models. If a better model ships next month, you switch from the dashboard — the integration does not change.

  • We connect, we do not replace

    The agent reaches the ERP, CRM or e-commerce you already run through MCP servers and APIs. Nothing has to be migrated to use MindLab.

  • Vision stays on your side

    The vision model runs on the machine in the branch. Frames are described locally; what leaves is text, not video.

  • Boring where it matters

    PostgreSQL, containers, infrastructure as code and typed services. The interesting part should be the agent, not the plumbing under it.

Next step

Want the details?

In a demo we walk your team through the architecture: integrations, data flows and what a deployment looks like on your side.

Book a demo