MCP server · language learning

Where your mistakes are remembered

LinguaTrack gives any AI tutor — voice or text — a persistent memory of the errors you make while learning a language. Every correction is saved, deduplicated into a pattern, and pulled back into your next conversation.

No signup, no email. One button, one key, and your assistant configures itself.

You Yesterday I go to the cinema with my friend.

Tutor Almost — yesterday I went to the cinema. Past simple after “yesterday”.

save_errors GRAMMAR / tenses · “I go” → “I went” · 4th time this month

Tutor That's the fourth time this month — let's drill past simple for two minutes.

Why it exists

Corrections evaporate

Every new chat starts from zero. Your tutor has no idea you dropped articles yesterday, so it corrects the same mistake forever and you never see the pattern.

Voice mode lost everything

The original ChatGPT plugin couldn't call the backend during voice sessions — precisely when you make the most mistakes. MCP is called the same way in voice and text.

One memory, any client

Claude, ChatGPT, Cursor, Gemini — every MCP-capable assistant reads and writes the same error database. Switch tools without losing your history.

How it works

01

Get your key

One click below. The server creates a learner profile and hands you a long-lived bearer key. Nothing to fill in.
02

Connect your assistant

Paste one line into your MCP client — or copy the onboarding prompt, drop it into the chat, and let the agent set itself up.
03

Just talk

The assistant saves every correction through save_errors and loads your weak spots at the start of each session. Repeats bump a counter instead of piling up duplicates.

What gets tracked

Severity

lowDoesn't impede understanding
mediumCauses slight confusion — the default
highSignificantly hinders communication

Lifecycle

active → improving → resolved

An error moves along as you stop making it. Nothing is deleted — resolved mistakes stay as evidence of progress.

Frequency

Saving the same mistake again doesn't create a second row: the server matches it, bumps frequency, and refreshes last_seen. That counter is what turns noise into “you do this every third sentence”.

Connect in 30 seconds

Your personal key

Creates a fresh learner profile. Whoever holds this key owns that history — treat it like a password and keep a copy.

YOUR KEY — SAVED IN THIS BROWSER ONLY

Every snippet below now contains your key. Lost it? Getting a new one starts an empty history — it does not recover the old profile.

One command. Works in any project.

claude mcp add --transport http lingotrack https://lingotrack.duckdns.org/mcp \
  --header "Authorization: Bearer <YOUR_KEY>"

Claude Desktop speaks stdio, so bridge the remote server with mcp-remote. Config file: ~/.config/Claude/claude_desktop_config.json (Linux), ~/Library/Application Support/Claude/claude_desktop_config.json (macOS), %APPDATA%\Claude\claude_desktop_config.json (Windows).

{
  "mcpServers": {
    "lingotrack": {
      "command": "npx",
      "args": [
        "mcp-remote", "https://lingotrack.duckdns.org/mcp",
        "--header", "Authorization: Bearer <YOUR_KEY>"
      ]
    }
  }
}

Settings → Connectors → Add custom connector (developer mode).

Name:  LinguaTrack
URL:   https://lingotrack.duckdns.org/mcp
Auth:  Custom header
       Authorization: Bearer <YOUR_KEY>

This is the path that fixed voice: the connector is invoked in voice sessions, unlike the old Actions plugin.

Project .cursor/mcp.json or the global ~/.cursor/mcp.json.

{
  "mcpServers": {
    "lingotrack": {
      "url": "https://lingotrack.duckdns.org/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_KEY>"
      }
    }
  }
}

~/.gemini/settings.json.

{
  "mcpServers": {
    "lingotrack": {
      "httpUrl": "https://lingotrack.duckdns.org/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_KEY>"
      }
    }
  }
}

Streamable HTTP, stateless, JSON responses. Any MCP client or plain HTTP works.

curl -sS https://lingotrack.duckdns.org/mcp \
  -H "Authorization: Bearer <YOUR_KEY>" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Or let the agent do it

Copy the onboarding prompt and paste it into any assistant. It contains the endpoint, your key, and the rules the tutor should follow — the agent configures the connection itself.

Open in Claude ↗ Open in ChatGPT ↗

The deep links carry the setup instructions but not your key — keys don't belong in URLs. Paste it when the agent asks; it's already on your clipboard.

MCP tools

Tool	What it does	REST equivalent
`whoami`	Identify the learner — id, CEFR level, native language	`GET /auth/me`
`list_errors`	List tracked mistakes, filtered by status or category	`GET /errors`
`save_errors`	Persist corrections; dedups and bumps frequency	`POST /errors/batch`
`update_error_status`	Move an error to active / improving / resolved	`PUT /errors/{id}/status`
`get_progress`	Aggregated report — weak areas, top errors, recommendations	`GET /progress`
`start_session`	Open a practice session	`POST /sessions`
`end_session`	Close a session with a summary	`PUT /sessions/{id}`

The server also ships MCP instructions, so a connected assistant knows to save every correction without being told — that rule travels with the server, not with your prompt.

One host, everything on it

`/mcp`	MCP endpoint — Streamable HTTP, bearer auth
`/api/v1`	REST API (the original Custom GPT plugin still uses it)
`/docs`	Interactive OpenAPI docs
`/openapi.json`	OpenAPI schema
`/llms.txt`	This page as plain text, for agents
`/health`	Health check

loading…