What is gotcontext.ai?

gotcontext.ai is a semantic compression MCP (Model Context Protocol) gateway that reduces LLM token usage by roughly 50% on typical inputs and up to 87.4% on large documents. It compresses every tool response before your agent reads it, so 5+ connected MCP servers do not flood the context window. It works with Claude Code, Cursor, Codex, and Gemini CLI using one bearer token at https://api.gotcontext.ai/mcp. Also available as a REST API, Python SDK, and TypeScript SDK. Free tier included, no credit card required.

How does gotcontext.ai reduce LLM token costs?

gotcontext.ai compresses the input context — documents, code, conversation history — before passing it to the LLM. The compression engine ranks content by semantic importance using graph-based PageRank, removes low-signal tokens, and returns a compressed skeleton. Because LLM pricing is per-token, sending fewer tokens directly reduces API cost, typically by 40–60% on average input and up to 85% on long redundant inputs.

How is gotcontext.ai different from LLMLingua?

LLMLingua (Microsoft Research) is an academic prompt compression method with no hosted API, no MCP server, and no SDKs. gotcontext.ai is a production-grade hosted API with REST endpoints, a Model Context Protocol (MCP) Streamable HTTP server, Python and TypeScript SDKs, a free tier, and a self-hosted Docker image. All paid plans include the same 140+ MCP tools (compression, ACE agent context engineering, knowledge management, multimodal ingestion); plans differ on monthly compression volume, embedding tier (TF-IDF / ONNX / SBERT), and enterprise wraparound (OIDC, audit-log export, SLA, support). LLMLingua requires running your own GPU inference; gotcontext.ai works with an API key.

Does gotcontext.ai work with Claude Code, Cursor, Codex, or Gemini?

Yes. Run "npx gotcontext wrap claude" to configure Claude Code, "npx gotcontext wrap codex" for OpenAI Codex CLI, or "npx gotcontext wrap gemini" for Google Gemini CLI. Each command writes the MCP server entry to the right config file automatically. Cursor and any other MCP-compatible client can also connect directly to https://api.gotcontext.ai/mcp using a Bearer API key. gotcontext.ai also ships a Claude Code plugin installable via /plugin marketplace add oimiragieo/gotcontext-plugin.

How do I install gotcontext.ai and start reducing token usage?

Get a free API key at https://gotcontext.ai/sign-up (no credit card required). Then run "npx gotcontext wrap claude" in your terminal to configure Claude Code automatically. For Codex CLI run "npx gotcontext wrap codex", for Gemini CLI run "npx gotcontext wrap gemini". After that, every tool response your agent reads is compressed by gotcontext.ai before it reaches the context window. Run "npx gotcontext doctor" to verify which CLIs are detected and configured. Full instructions at https://gotcontext.ai/docs/getting-started.

Does gotcontext.ai handle high-traffic load fairly across plans?

Yes. gotcontext.ai uses a plan-priority compression queue: each tier has its own pool of concurrent compression slots — Enterprise gets 8 slots, Team gets 4, Pro gets 2, Free gets 1. Pools are isolated, so a flood of Free traffic cannot starve a paying Enterprise customer (similar to Anthropic Priority Tier and OpenAI Priority API). When a tier reaches its slot cap, additional requests wait briefly rather than being rejected with 429, and only return HTTP 503 with a Retry-After hint after a timeout. This is reserved capacity by design, not queue jumping.

Is gotcontext.ai self-hostable for enterprise?

Yes. Enterprise customers get a Docker image that runs entirely in your VPC, with OIDC federation (Okta, Auth0, Azure AD, Keycloak), audit-log export (NDJSON or CSV) for SOC2 evidence pipelines, Ed25519-signed license JWTs, SSO/SAML, dedicated SLA with uptime credits, named CSM with 4h critical response, and a custom MSA / DPA / IP indemnity. Usage metering reports back to a control plane you choose, including air-gapped operation. Enterprise differs from Pro/Team on compliance, deployment, support, and contract terms — all three paid tiers include the same 140+ MCP tools and the same compression engine.

gotcontext.ai is a semantic compression MCP (Model Context Protocol) gateway that reduces LLM token usage by roughly 50% on typical inputs and up to 87.4% on large documents. It works with Claude Code, Cursor, Codex, and Gemini CLI using one bearer token at https://api.gotcontext.ai/mcp. Activate with npx gotcontext wrap claude. Getting started guide · Compare with alternatives.

MCP Gateway

50% de réponses d’outils plus légères en moyenne. Un seul token porteur.

Pointez votre client MCP vers https://api.gotcontext.ai/mcp, ajoutez votre clé, et chaque réponse d’outil est compressée avant que votre agent la lise. Compatible avec Claude Code, Cursor, Codex et Gemini CLI, 140+ outils.

Obtenir votre clé API gratuite

Offre gratuite : 1 000 compressions/mois, sans carte bancaire.

Lire la documentation →Essayez en direct

50% d’économie typique (/v1/global-savings en direct est plus élevé)87,4 % de pic de référence sur les grands documentsexécutez vous-même le banc de test →

Image Docker auto-hébergée disponible Journaux d'audit exportables (NDJSON/CSV)OIDC / SSO / DPA

Essayez, sans inscription5 300 / 12 000

# Service Operations Runbook: Payments API

## Purpose and scope

This runbook covers the payments-api service: what it does, how it is deployed, what its dependencies are, and what to do when it misbehaves. It is written for the on-call engineer. Every procedure here assumes you have production read access and the ability to trigger a deploy through the standard pipeline. Nothing in this document requires direct database write access, and no procedure here should be improvised under pressure: if the situation is not covered, page the service owner rather than inventing a fix at 3am.

The payments-api accepts charge requests from the checkout frontend, validates them against the pricing catalog, forwards them to the payment processor, and records the outcome in the orders database. It is the only service permitted to talk to the processor. Average traffic is steady during business hours with a daily peak around 19:00 UTC and a weekly peak on Friday evenings.

## Architecture and dependencies

The service runs as three replicas behind the regional load balancer. Each replica is stateless; all persistent state lives in the orders database and the idempotency-key store. The service depends on four things: the orders database (primary and one read replica), the idempotency-key store, the pricing catalog service, and the external payment processor. Of these, only the processor is outside our control.

Dependency failure behavior is deliberate and asymmetric. If the pricing catalog is unreachable, the service serves prices from its local cache for up to ten minutes and emits a degraded-mode metric. If the idempotency store is unreachable, the service refuses new charges entirely, because accepting a charge without idempotency protection risks double-billing, and double-billing is strictly worse than downtime. If the processor times out, the charge is recorded as pending and a reconciliation job resolves it within the hour.

## Deployment

Deploys go through the standard pipeline: merge to main, automated tests, staging deploy, a thirty-minute soak with synthetic checkout traffic, then production rollout one replica at a time. The pipeline aborts automatically if the error rate on the new replica exceeds the old baseline. A full rollout takes about twenty minutes. Rollback is the same pipeline in reverse and takes about six minutes; the on-call engineer can trigger it without approval. Database migrations ship separately from code, are always backwards-compatible for at least one release, and run before the code that needs them.

## Monitoring and alerts

Three alerts page the on-call engineer. High charge failure rate fires when more than two percent of charge attempts fail over five minutes; the usual causes are a processor incident or a bad deploy, in that order. Idempotency store unavailable fires immediately on connection failure, because the service is refusing charges while it is down. Reconciliation backlog fires when pending charges older than ninety minutes accumulate, which usually means the reconciliation job is stuck rather than the processor being slow.

Two further signals warn without paging: elevated latency on the catalog cache path, and a rising rate of declined cards, which is almost always upstream issuer behavior rather than anything on our side. Dashboards live in the standard observability stack; the service overview board links to per-dependency drill-downs.

## Common incidents and procedures

Processor outage: confirm against the processor status page first. Do not roll back, the deploy is not the cause. Charges queue as pending and reconcile automatically when the processor recovers. Communicate the expected resolution path to support so they can answer customer tickets accurately.

Bad deploy: the symptom is a failure-rate alert that begins within minutes of a rollout completing. Trigger rollback first and investigate second; the six-minute rollback is always cheaper than debugging in production. Capture the failing release tag in the incident channel before it scrolls away.

Idempotency store failure: this is the highest-urgency scenario because the service is intentionally refusing all new charges. Verify whether the store itself is down or the network path to it is broken. The store runs with a replica that takes over automatically; if failover has not happened within two minutes, force it using the documented store-failover procedure, then watch the charge acceptance rate recover.

Reconciliation backlog: restart the reconciliation job first; a stuck job accounts for nearly every historical occurrence. If the backlog continues to grow after a restart, check whether the processor is returning errors on the reconciliation endpoint specifically, which has happened during their maintenance windows even when charging worked normally.

## Post-incident

Every paging incident gets a written timeline within one business day, while details are fresh. The timeline records when the alert fired, what was tried, what worked, and what the customer-visible impact was. Action items get owners and dates, and the runbook section that failed to cover the incident gets updated in the same pull request as the timeline. A runbook that does not absorb its incidents is decoration, not documentation.

Compatible avec

Claude Code

Cursor

Gemini CLI

Codex

Windsurf

VS Code

Pipeline de compression

Comment une réponse est compressée.

Même entrée, même résultat, à chaque exécution. Quatre étapes, aucun modèle dans la boucle. Le résultat est un re-classement de vos propres phrases. Chaque token de la réponse compressée figure dans l’original.

Étape 1 : Ingestion

Analyse du document

Texte segmenté, analysé et évalué sémantiquement. Graphe de compression assemblé.

Étape 2 : Classement

Score PageRank

Arêtes du graphe pondérées par similarité sémantique. Importance propagée dans le réseau.

Étape 3 : Extraction

Extrait classé (non généré)

Les nœuds les mieux classés forment le résultat compressé. Chaque token de sortie figure dans votre entrée. Le ratio cible contrôle la fidélité.

Étape 4 : Livraison

Retour au client MCP

Résultat compressé renvoyé à votre outil IA, généralement ~50 % plus petit sur le trafic en production (87,4 % au pic de référence). Développable à la demande.

Comment ça fonctionne

Pourquoi le résultat est vérifiable.

Pas un résumé. Un re-classement de vos propres phrases. Les documents sont segmentés, encodés et évalués sur un graphe sémantique ; seuls les nœuds les mieux classés survivent dans le résultat. Généralement ~50 % plus petit sur le trafic en production. Méthodologie et pic de référence dans la section mesure. section mesure.

Trois modes de compression : rapide / équilibré / SBERT
Compression de code AST pour 7+ langages
Isolation des clés par espace de travail. Les clés ne peuvent pas lire entre les espaces de travail.
Palette de commandes : navigation Cmd+K, raccourcis G+D, recherche plein texte
Intégration GitHub : résumés d'économies de tokens publiés sur vos pull requests
Moniteur de file en temps réel : streaming SSE en direct pour les traitements par lots
Rôles : Propriétaire, Administrateur, Membre, Observateur. Projets partagés, journal d’activité.
Compatible avec le cache de prompt natif (Anthropic / OpenAI / Gemini). Lorsque les deux s’appliquent, la réduction totale peut atteindre 95 %. Voir la méthodologie.

COMPRESSION

Semantic Graph

PageRank-based importance scoring

50% live average

Developer First

140+ outils MCP derrière un seul point de terminaison.

Compatible avec tout client MCP. Claude Code, Codex, Gemini CLI, Cursor, VS Code. Une seule commande configure le serveur MCP, sans édition JSON.

Protection contre la traversal de chemin CWE-22 sur toutes les E/S de fichiers
Ingestion par lots asynchrone : 4× le débit
Métriques Prometheus, traçage OpenTelemetry, contrôles de santé
gc_compress_manifest réduit la verbosité des descriptions d’outils MCP

Voir la documentation API

Configuration en une commande

1. Obtenez une clé gratuite depuis le tableau de bord
2. Lancez la CLI. Elle demande votre clé
3. Redémarrez votre CLI

$ npx gotcontext wrap claude

Also: npx gotcontext doctor — shows which CLIs are detected and configured.

Préférer la configuration JSON manuelle ?

.mcp.json

{
  "mcpServers": {
    "gotcontext": {
      "url": "https://api.gotcontext.ai/mcp",
      "headers": {
        "Authorization": "Bearer gc_your_key_here"
      }
    }
  }
}

terminal

live

# 1. Get a free API key at gotcontext.ai/sign-up

# 2. Point your AI tool at our MCP endpoint:

https://api.gotcontext.ai/mcp

Authorization: Bearer gc_your_key

# 3. Call tools naturally (Claude Code / Cursor / etc):

> ingest_context(file_id="api.md", content="...")

> read_skeleton(file_id="api.md", ratio=0.15)

# Result: 485 → 61 tokens (87.4% reduction)

50%

Compression live moyenne

<90ms

Latence p95 du pipeline

140+

Outils MCP

Try it now

Paste any text and see how much you can save. No signup required.

Text is processed in-memory and is not stored, logged with PII, or used for training. Do not paste secrets or production credentials. Privacy details →

Input text

# Service Operations Runbook: Payments API

## Purpose and scope

## Architecture and dependencies

## Deployment

## Monitoring and alerts

## Common incidents and procedures

## Post-incident

5,300/12,000 chars

Compressed output

Compressed text will appear here...

Compression de code

Votre base de code est ce que votre agent lit le plus.

Les résumeurs de texte compressent la prose. Nous compressons le code, avec conscience de l'AST, préservation de la structure, à 10-11× sur de vrais fichiers source. Un agent qui lit mcp_gateway.py en entier dépense 20 076 mots de contexte. Avec read_skeleton, il obtient un squelette structurel fidèle en 1 935 mots et explore toute fonction à la demande. Mêmes questions répondables, un dixième du budget de contexte.

Dogfood en direct : notre propre passerelle

10.38×

compression sur api/app/mcp_gateway.py (~5,5 K LoC, production)

read_file20,076 mots

read_skeleton1,935 mots

L'agent reçoit un squelette structurel (chaque signature de fonction, chaque classe, chaque import), puis appelle modulate_region pour développer n'importe quelle section. gc_blast_radius fournit un contexte classifié pour un symbole précis. compress_codebase produit un résumé AST d'un répertoire entier.

read_skeletonmodulate_regiongc_blast_radiuscompress_codebase

Résultats de référence (verrouillés en CI)

Entrée

Original

Squelette

Ratio

Économisé

Fichier de code (source réelle)

3,390

299

11.34×

91.2%

api/app/mcp_gateway.pydogfood

20,076

1,935

10.38×

90.4%

Grand document (~2 300 mots)

7,173

752

9.54×

89.5%

La compression dépend de la taille. Les petits fichiers compriment peu. Le moteur les conserve fidèlement. Les ratios ci-dessus concernent les grands fichiers que les agents ont du mal à intégrer intégralement dans leur contexte.

Lire la documentation

Comment nous mesurons

Comment les chiffres sont mesurés.

Deux sources : l’API en direct et un benchmark ouvert que vous pouvez exécuter. Le chiffre du hero est une estimation prudente d’environ 50 % ; la moyenne de production en direct, plus élevée, se trouve au point de terminaison /v1/global-savings Le pic de référence ci-dessous provient du benchmark open source. Exécutez-le vous-même, les chiffres seront identiques. Code context is powered by tensor-grep (open source, Apache-2.0).

87.4%

Pic de référence : documents longs

Pic sur les documents longs (specs API, bases de code, articles de recherche). Le chiffre principal est une estimation prudente d’environ 50 % ; la moyenne de production en direct est plus élevée. Les deux chiffres sont réels, la différence tient au mix de charge.

Voir les benchmarks publics

140+

Outils MCP

Claude, GPT, Gemini, Codex.

<90ms

Latence du pipeline

Ingestion → compression → retour, p95.

Intégrations CLI

Claude Code, Cursor, Gemini CLI, Codex, Windsurf.

Tarifs

Payez pour les appels d’outils. La compression est incluse.

Chaque réponse d’outil MCP est compressée avant d’être renvoyée à votre agent. Chaque appel offre ainsi une valeur de contexte nettement supérieure par budget de tokens. Le multiplicateur évolue avec le ratio de compression en direct (voir le hero). Des développeurs individuels aux grandes équipes.

Gratuit

$0/month

Plan gratuit

Sans carte bancaire. Destiné à l’évaluation et aux projets personnels.

1 000 compressions/mois
100 Ko taille max du document
Compression standard
Palette de commandes et raccourcis
Journal d’activité
Thème sombre/clair
Support communautaire

Commencer gratuitement : 1 000 compressions/mois

Pro

$49/mo

Pour les développeurs individuels

Tous les 140+ outils MCP, compression accélérée, file prioritaire avec 2 créneaux de compression réservés.

50 000 compressions/mois
Tous les 140+ outils MCP (incl. ACE, gestion des connaissances, multimodal)
File prioritaire : 2 créneaux de compression simultanés
1 Mo taille max du document
Compression accélérée (3 à 5× plus rapide)
Moniteur de file (SSE en temps réel)
Analytiques d’utilisation
Notifications webhook
Support prioritaire

Démarrer le plan Pro

Business

$199/mo

Infrastructure partagée avec journaux d'audit exportables, OIDC/SSO et DPA

Docker auto-hébergé, OIDC/SSO, export du journal d’audit pour vos revues de conformité, embeddings SBERT, Customer Success Manager dédié.

500 000+ compressions / mois
Tous les 140+ outils MCP
File prioritaire : 8 créneaux de compression simultanés
Docker auto-hébergé (déployez dans votre VPC)
Fédération OIDC (Okta, Auth0, Azure AD)
Export du journal d’audit (NDJSON/CSV) pour les revues de conformité
Embeddings SBERT (fidélité supérieure au niveau MiniLM par défaut)
SSO / SAML
Support par e-mail · SLA sur demande (MSA personnalisé)
DPA / indemnité IP / MSA personnalisé

Contacter les ventes

Voir la comparaison complète des plans (Gratuit · Pro · Team · Enterprise)

FROM THE BLOG

What we're measuring and writing about context

Read the blog →

Research2026-07-08

Token-level compression breaks agents at any ratio

A 2026 study ran standard token-pruning compressors on LLM agents across 17 configurations. Every one collapsed to near-zero reward, from 1.3x to 13.3x compression. The tokens a compressor drops first are the ones agents need most.

Read →

Research2026-07-08

Compressing prompts harder made them more expensive

A pre-registered randomized trial compressed production agent prompts at three retention rates. Keeping half the tokens cut total cost 27.9%. Keeping a fifth raised cost 1.8%, because the model wrote longer outputs.

Read →

Research2026-07-08

When to compact matters more than how much

JHU and Apple researchers let the model decide when to summarize its own context, guided by a short rubric. Up to 18.1 points better on math and 5 to 9 on agentic search than never summarizing, at 30 to 70% lower cost.

Read →

Commencer aujourd’hui

Commencez gratuitement.

1 000 compressions/mois, tous les 140+ outils, sans carte bancaire.

Créer un compte gratuit Lire la documentation