DEV Community: Nicolette Rankin

MCP for Language: Adding a Dictionary to Your AI Agent in One Line

Nicolette Rankin — Sun, 01 Mar 2026 14:57:18 +0000

Your Agent Doesn't Have a Dictionary

Open your MCP config. You've probably got tools for search, databases, APIs, file systems, maybe code execution. Your agent can query Postgres, hit a REST endpoint, read a PDF, and write to S3.

Now ask yourself: what tool gives your agent verified vocabulary?

When your agent explains a word, it generates the definition from its training data. It might be right. It might be subtly wrong. It's different every time. There's no ground truth.

For casual use, this is fine. For educational robots, language learning platforms, or any application where children are involved, "probably right" isn't good enough.

Word Orb as MCP Server

One line in your MCP config:

{
  "mcpServers": {
    "word-orb": {
      "url": "https://word-orb-api.nicoletterankin.workers.dev/mcp"
    }
  }
}

That's it. Works with Claude Desktop, ChatGPT, Cursor, Gemini, and any MCP-compatible client. Your agent now has access to:

word_lookup — Verified definition, etymology, translations across 47 languages, age-appropriate explanations, and pronunciation audio for any word
kelly_audit — Vocabulary quality assessment
translate — Translations with native script and phonetic pronunciation for 47 languages

What You Get

A single call to word_lookup returns structured data across multiple dimensions:

Verified definitions backed by etymology. Not a hallucinated summary. The definition traces the word through its linguistic roots. Deterministic — same word, same response, every time.

47-language translations with native script and phonetic pronunciation. Arabic in Arabic script with transliteration. Mandarin in characters with pinyin. Japanese with romaji. Your multilingual agent doesn't guess at translations — it looks them up.

Age-appropriate tones. Four registers: child (5-12), teen, adult, and elder (65+). Your agent adjusts vocabulary based on who it's talking to:

"courage" for a 5-year-old:
"Being brave even when you feel scared inside."

"courage" for an adult:
"The mental or moral strength to persevere through fear or adversity."

240,000 pronunciation audio files. Robots and voice assistants can play actual recorded pronunciation, not TTS approximations.

Framework Integration Examples

MCP is the cleanest path, but Word Orb works with whatever you're building on.

LangChain (Python)

from langchain.tools import BaseTool
import requests

class WordOrbTool(BaseTool):
    name = "word_orb_lookup"
    description = "Look up a word for verified definition, translations, and pronunciation"

    def _run(self, word: str) -> str:
        resp = requests.get(
            f"https://word-orb-api.nicoletterankin.workers.dev/api/word/{word}",
            headers={"Authorization": "Bearer wo_YOUR_KEY"}
        )
        return str(resp.json())

CrewAI (Python)

from crewai.tools import BaseTool
import requests

class WordOrbTool(BaseTool):
    name = "Dictionary Lookup"
    description = "Look up vocabulary for accurate, age-appropriate definitions"

    def _run(self, word: str) -> str:
        resp = requests.get(
            f"https://word-orb-api.nicoletterankin.workers.dev/api/word/{word}",
            headers={"Authorization": "Bearer wo_YOUR_KEY"}
        )
        return str(resp.json())

OpenAI Function Calling (JavaScript)

const tools = [{
  type: 'function',
  function: {
    name: 'word_orb_lookup',
    description: 'Look up a word for verified definition, translations, and audio',
    parameters: {
      type: 'object',
      properties: { word: { type: 'string' } },
      required: ['word']
    }
  }
}];

npm Package

npm install @lotd/word-orb

const WordOrb = require('@lotd/word-orb');
const orb = new WordOrb('wo_YOUR_KEY');
const word = await orb.word('courage');

The Numbers

Metric	Value
Words	162,250
Languages	47
Translations	846,742
Audio files	240,297
Teaching archetypes	12
Age groups	4
Response time (p50)	3ms
Edge locations	300+

Who Uses This

Word Orb was built to power thedailylesson.com — 62,000 lesson segments across 11 languages and 3 age groups. The same infrastructure is now available to any educational AI system, robot, or agent that needs reliable vocabulary.

Get Started

MCP config (one line):

{"mcpServers":{"word-orb":{"url":"https://word-orb-api.nicoletterankin.workers.dev/mcp"}}}

API and pricing: word-orb-api.nicoletterankin.workers.dev/pricing

npm: npm install @lotd/word-orb

GitHub: nicoletterankin/word-orb

Free tier: 50 calls/day. No credit card. Instant API key.

Built by Lesson of the Day PBC.

How We Built a 162K-Word Database on Cloudflare Workers + D1

Nicolette Rankin — Sun, 01 Mar 2026 14:47:52 +0000

We needed a dictionary that runs at the edge. Not a wrapper around an existing API — a full database with definitions, etymology, translations, pronunciation data, and age-appropriate explanations, all served from SQLite co-located with the compute.

Here's how we built it.

The Requirements

Our product (thedailylesson.com) serves 62,000 lesson segments in 11 languages and 3 age groups. Every lesson needs vocabulary: definitions, translations, pronunciation, and explanations calibrated for the learner's age.

We needed:

162,250 words with verified definitions and etymology
846,000 translation rows across 47 languages with native script
240,000 audio files for pronunciation
Sub-50ms response globally
No cold starts — educational applications can't tolerate 500ms+ delays

Why D1 (SQLite at Edge)

The first decision was the database. Options:

Option	Pros	Cons
Postgres (Neon, Supabase)	Familiar SQL, rich features	Connection pooling overhead, cold starts, network round-trip
D1 (SQLite at edge)	Co-located with Workers, no connection pooling, fast reads	Write latency, 10GB limit, newer service
KV	Global edge reads	No SQL, key-value only, eventual consistency
Durable Objects	Strong consistency	Overkill for read-heavy reference data

D1 won because our workload is overwhelmingly reads. A dictionary is reference data — we write once (or rarely), read millions of times. SQLite excels at this. No connection pool to manage. No cold-start penalty. The database is literally sitting next to the Worker.

Schema Design

Three tables:

CREATE TABLE words (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  word TEXT UNIQUE NOT NULL,
  def TEXT,
  ipa TEXT,
  pos TEXT,
  etymology TEXT,
  tone_child TEXT,
  tone_teen TEXT,
  tone_adult TEXT,
  tone_elder TEXT,
  teaching_archetypes TEXT,
  lookups INTEGER DEFAULT 0,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE translations (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  word_id INTEGER REFERENCES words(id),
  lang TEXT NOT NULL,
  translated_word TEXT,
  native_script TEXT,
  phonetic TEXT,
  UNIQUE(word_id, lang)
);

CREATE TABLE ethics (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  word_id INTEGER REFERENCES words(id),
  category TEXT,
  detail TEXT,
  alternatives TEXT
);

The translations table uses a composite unique constraint on (word_id, lang) — this keeps translation lookups to a single index scan.

The Data Pipeline

Getting 162,250 words into D1 required a bulk insert strategy. D1 doesn't have COPY or bulk import like Postgres. We wrote a batch inserter:

Generate word data in batches of 50 (definitions, etymology, translations, tones)
POST each batch to an internal endpoint on the Worker
The Worker inserts into D1 using a transaction
Rate-limit to avoid D1's write throughput limits

The full pipeline took several days to run. 162,250 words x 47 languages = 846,000 translation rows. Each word also gets 4 age-appropriate tone variants and etymology.

Audio Storage in R2

240,000 pronunciation files went into R2 (Cloudflare's S3-compatible object storage). We organized them by path:

/audio/pronunciation/{word}.mp3
/audio/kelly_says/{word}.mp3

The upload pipeline used a parallel worker script that:

Reads audio files from the local filesystem
PUTs each file to R2 via the Worker's internal upload endpoint
Retries on transient R2 errors (we hit 13 across 240K files)

Total upload time: ~189 minutes for 240,297 files. R2 was remarkably stable.

Serving is simple — the Worker reads from R2 and returns the file with appropriate Content-Type and Cache-Control headers. Cloudflare's CDN caches hot audio files at the edge automatically.

Cache-Miss Generation

The most interesting architectural decision: what happens when someone requests a word that isn't in the database?

We generate it on demand:

// Pseudocode
async function handleWord(word, env) {
  // Try D1 first
  let row = await env.DB.prepare("SELECT * FROM words WHERE word = ?").bind(word).first();
  if (row) return row;

  // Cache miss — generate
  const generated = await generateWord(word);

  // Store permanently in D1
  await env.DB.prepare("INSERT INTO words ...").bind(...generated).run();
  await insertTranslations(env, generated.translations);

  return generated;
}

First request: 2-4 seconds (generation + D1 write). Every subsequent request: ~3ms (D1 read from edge). The dictionary grows organically.

Performance Results

After deployment:

Metric	Value
p50 response time	3ms
p99 response time	48ms
Total words	162,250
Total translations	846,742
Audio files	240,297
Edge locations	300+
Uptime	99.99%

The p99 spike to 48ms happens on cache misses to D1's read replicas. For a dictionary API, this is more than acceptable.

MCP Server

We exposed the API as an MCP server so AI agents can use it natively:

{
  "mcpServers": {
    "word-orb": {
      "url": "https://word-orb-api.nicoletterankin.workers.dev/mcp"
    }
  }
}

This works with Claude Desktop, ChatGPT, Cursor, Gemini, and any MCP-compatible client. The agent can look up words, get translations, and access pronunciation audio through natural language.

Lessons Learned

D1 is excellent for read-heavy reference data. If your data changes infrequently and you need global edge reads, it's the right choice.
R2 bulk uploads are reliable. 240K files with only 13 transient errors is impressive. Just build retry logic.
Cache-miss generation is powerful. Start with a large seed database, then let it grow. Users get fast responses for known words and acceptable latency for new ones.
Audio files belong in object storage, not databases. This seems obvious, but the temptation to base64-encode audio into a database column is real. Don't.
Composite indexes matter for translations. Without UNIQUE(word_id, lang), translation lookups would scan the full 846K-row table.

Try It

API: word-orb-api.nicoletterankin.workers.dev/pricing
npm: npm install @lotd/word-orb
GitHub: nicoletterankin/word-orb

Free tier: 50 calls/day, no credit card.

Built by Lesson of the Day PBC. Powers 62,000 lesson segments across 11 languages and 3 age groups.

Building a Dictionary API for AI Agents: 162K Words at the Edge

Nicolette Rankin — Sun, 01 Mar 2026 14:46:36 +0000

Your AI agent doesn't have a dictionary.

When a user asks your agent what a word means, the LLM generates a plausible-sounding definition. It might be right. It might be subtly wrong. It might be different every time. There's no ground truth underneath.

For most applications, this is fine. For educational robots teaching children, language learning platforms, or any system where vocabulary accuracy matters — it's not.

The Problem

LLMs are probabilistic. Every response is a new generation. Ask the same model the same question twice and you may get different answers. For creative writing, this is a feature. For a dictionary, it's a bug.

Educational applications need:

Consistent definitions that don't change between requests
Age-appropriate explanations (a 5-year-old needs different language than an adult)
Accurate translations with proper native script (not romanized approximations)
Pronunciation audio (robots need to speak words correctly)
Etymology (teachers want to explain where words come from)

No LLM provides this reliably out of the box.

Word Orb: The Infrastructure Layer

We built Word Orb as the vocabulary infrastructure for our own product — thedailylesson.com, which serves 62,000 lesson segments in 11 languages and 3 age groups.

One API call returns a structured word object:

{
  "word": "courage",
  "def": "The mental or moral strength to face fear, danger, or difficulty",
  "ipa": "/kɜːrɪdʒ/",
  "pos": "noun",
  "etymology": "From Old French corage, from Latin cor (heart)",
  "tones": {
    "child": "Being brave even when you feel scared inside.",
    "teen": "The strength to face fear, pain, or difficulty head-on.",
    "adult": "The mental or moral strength to persevere through fear or adversity.",
    "elder": "A lifelong companion — the quiet resolve that carries us through uncertainty."
  },
  "langs": {
    "es": { "word": "coraje", "phonetic": "ko-RA-he" },
    "zh": { "word": "勇气", "phonetic": "yǒng qì" },
    "ar": { "word": "شجاعة", "phonetic": "sha-JAA-ah" }
  }
}

Every response is deterministic. Same word, same result, every time. The definitions are backed by etymology, not generated on the fly.

The Architecture

Word Orb runs on Cloudflare's edge stack:

Workers — API compute at 300+ edge cities (~3ms response)
D1 — SQLite at the edge for 162,250 words and 846,000 translation rows
R2 — Object storage for 240,000 pronunciation audio files
KV — Edge caching for hot words

Why D1 over Postgres? No connection pooling. SQLite is co-located with the Worker. A word lookup is a single query against a local database, not a network round-trip to a remote instance. The difference shows up in tail latencies: our p99 is under 50ms globally.

Why R2 for audio? 240,000 pronunciation files can't live in a database. R2 gives us S3-compatible object storage with no egress fees. Files are served through Cloudflare's CDN automatically.

Cache-Miss Generation

When someone requests a word that isn't in the database, Word Orb generates it in real time — definition, etymology, translations, pronunciation data, and age-appropriate tones. This takes 2-4 seconds on the first request. The result gets written to D1 and cached permanently. Every subsequent request hits the edge database at 3ms.

This means the dictionary grows organically. Start with 162K words, and it expands as users request new terms.

Why Audio Matters

Educational robots and voice assistants need to pronounce words correctly. TTS can approximate this, but it gets pronunciation wrong for unfamiliar words, loanwords, and proper nouns.

Word Orb stores pronunciation audio files in R2, organized by word:

/audio/pronunciation/{word}.mp3
/audio/kelly_says/{word}.mp3

The pronunciation path gives you clean dictionary pronunciation. The kelly_says path gives you the word used in an educational sentence.

Age-Appropriate Tones

Every word has four tone variants. This is the feature educational systems need most.

A robot explaining "mortality" to a 5-year-old:

"It means that every living thing has a beginning and an ending, like how flowers bloom and then go to sleep."

The same robot explaining "mortality" to an adult:

"The condition of being subject to death; the state of human finitude."

This is pedagogically informed content structuring. The child explanation uses concrete metaphors. The adult explanation uses precise terminology. The elder explanation acknowledges lived experience.

MCP Integration

Word Orb is an MCP server. One line in your config:

{"mcpServers":{"word-orb":{"url":"https://word-orb-api.nicoletterankin.workers.dev/mcp"}}}

Works with Claude Desktop, ChatGPT, Cursor, Gemini, and any MCP-compatible client.

npm Package

npm install @lotd/word-orb

const WordOrb = require('@lotd/word-orb');
const orb = new WordOrb('wo_YOUR_KEY');
const word = await orb.word('courage');
console.log(word.tones.child);

Who This Is For

Educational robot companies — pronunciation audio, age-appropriate language, multilingual support
Language learning platforms — 47-language translations with native script and phonetics
Teaching AI assistants — 12 pedagogical archetypes, verified definitions
Any AI agent that talks to humans — deterministic vocabulary, not hallucinated

Try It

Free tier: 50 calls/day, no credit card. Instant API key.

API: word-orb-api.nicoletterankin.workers.dev/pricing
npm: @lotd/word-orb
GitHub: nicoletterankin/word-orb

Word Orb is built by Lesson of the Day PBC and powers the vocabulary layer for 62,000 lesson segments across 11 languages and 3 age groups.