{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"awesome-lingo-dev","slug":"lingo-dev","name":"Lingo.dev","type":"mcp","url":"https://github.com/lingodotdev/lingo.dev/blob/main/mcp.md","page_url":"https://unfragile.ai/lingo-dev","categories":["mcp-servers"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"awesome-lingo-dev__cap_0","uri":"capability://data.processing.analysis.llm.powered.multi.format.static.file.translation.with.provider.abstraction","name":"llm-powered multi-format static file translation with provider abstraction","description":"Translates static content files (JSON, YAML, CSV, PO, Markdown) by parsing them into an intermediate representation, routing translation requests through a pluggable LLM provider layer (Lingo.dev Engine, OpenAI, Anthropic, Google, Mistral, OpenRouter, Ollama), and writing localized output files with an i18n.lock manifest tracking translation state. The compiler uses AST-aware parsing per format to preserve structure and metadata during round-trip translation.","intents":["I want to translate my app's static content files into 50+ languages without manually managing translation workflows","I need to swap between different LLM providers (OpenAI to Anthropic) without rewriting translation logic","I want to track which strings have been translated and which need updates via a lock file"],"best_for":["teams building multilingual web/mobile apps with centralized content files","developers wanting LLM-driven i18n without vendor lock-in","projects needing deterministic, reproducible translations across CI/CD runs"],"limitations":["Translation quality depends entirely on the chosen LLM provider; no built-in quality gates or human review workflows","Large translation batches may incur significant LLM API costs; no cost estimation or budgeting built-in","i18n.lock manifest can become stale if translations are modified outside the CLI/compiler pipeline","No support for context-aware translation hints (e.g., 'this button label should be <10 chars')"],"requires":["Node.js 18+","API key for at least one LLM provider (Lingo.dev Engine, OpenAI, Anthropic, Google, Mistral, OpenRouter, or Ollama)","Static content files in supported formats (JSON, YAML, CSV, PO, Markdown)"],"input_types":["JSON files","YAML files","CSV files","PO (gettext) files","Markdown files"],"output_types":["Translated JSON files","Translated YAML files","Translated CSV files","Translated PO files","Translated Markdown files","i18n.lock manifest (JSON)"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_1","uri":"capability://code.generation.editing.build.time.jsx.tsx.compiler.with.localization.injection.and.code.splitting","name":"build-time jsx/tsx compiler with localization injection and code splitting","description":"Integrates into Next.js, Vite, or webpack build pipelines via withLingo() wrapper or lingoCompilerPlugin() to intercept JSX/TSX source files, extract translatable strings, invoke LLM translation, and inject localized content into separate .lingo/ cache bundles per locale. The new compiler (@lingo.dev/compiler) uses AST transformation to rewrite component imports and string literals, enabling zero-runtime overhead for static translations while maintaining source map fidelity.","intents":["I want translations baked into my JS bundles at build time so there's no runtime translation latency","I need to automatically extract translatable strings from my React components without manual annotation","I want separate optimized bundles per language so users only download their locale's translations"],"best_for":["Next.js and Vite projects prioritizing build-time optimization and zero-runtime i18n overhead","teams with large component libraries needing automated string extraction across hundreds of files","applications targeting multiple locales where bundle size per language matters"],"limitations":["Requires build-time LLM API calls, which can slow down CI/CD pipelines for large projects (100+ translatable strings may add 30-60s per build)","Dynamic string translation (runtime user input) not supported; only static JSX strings are compiled","Legacy compiler (@lingo.dev/_compiler) is deprecated; migration to new compiler required for new projects","Source map generation adds ~10-15% to build time; can be disabled for production if needed"],"requires":["Next.js 13+ or Vite 4+ or webpack 5+","React 16.8+ (for hooks support in compiled components)","TypeScript 4.5+ (optional but recommended for type safety)","API key for LLM provider"],"input_types":["JSX/TSX source files","React component files","String literals in components"],"output_types":["Localized JS bundles in .lingo/ cache directory","Source maps per locale","Compiled component imports with locale-specific variants"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_10","uri":"capability://code.generation.editing.react.component.localization.with.hooks.and.context.providers","name":"react component localization with hooks and context providers","description":"Provides React-specific bindings (in @lingo.dev/react package) including hooks (useLocale, useTranslate) and context providers that integrate Lingo.dev translations into React component trees. The React package wraps the SDK to provide idiomatic React patterns, enabling components to access current locale, trigger locale switches, and subscribe to translation updates without prop drilling.","intents":["I want to use React hooks to access translations in my components without prop drilling","I need to switch locales globally and have all components re-render with new translations","I want to access the current locale in my components for conditional rendering"],"best_for":["React and Next.js applications using Lingo.dev for localization","teams preferring hooks-based patterns over render props or HOCs","projects with deeply nested component trees where prop drilling is problematic"],"limitations":["React package is React 16.8+ only (requires hooks support); no support for class components","Context-based locale switching causes all subscribed components to re-render; no fine-grained update control","No built-in memoization of translation results; components may re-render unnecessarily on locale changes","Hooks cannot be used in conditional logic; locale must be determined at component render time"],"requires":["React 16.8+","npm package @lingo.dev/react","Lingo.dev SDK (@lingo.dev/sdk)"],"input_types":["React components","Locale context"],"output_types":["Localized component output","Locale state updates"],"categories":["code-generation-editing","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_11","uri":"capability://memory.knowledge.translation.state.tracking.with.i18n.lock.manifest.and.incremental.updates","name":"translation state tracking with i18n.lock manifest and incremental updates","description":"Maintains an i18n.lock manifest file that tracks the translation state of every string (which strings have been translated, which are pending, which have changed since last translation). The lock file enables incremental translation workflows where only changed or new strings are re-translated, reducing API costs and improving CI/CD performance. Lock file is version-controlled alongside source code, providing an audit trail of translation history.","intents":["I want to only re-translate strings that have changed since my last translation run","I need to track which strings are pending translation vs. already translated","I want an audit trail of when each string was translated and by which provider"],"best_for":["teams with large translation volumes where incremental updates reduce costs","projects with frequent content updates requiring continuous localization","organizations needing audit trails and translation history"],"limitations":["Lock file can become stale if translations are modified outside the CLI/compiler pipeline (e.g., manual edits)","Lock file format is internal and not documented; direct manipulation is not recommended","No conflict resolution if lock file is edited by multiple processes simultaneously","Lock file size grows with project size; very large projects may have multi-MB lock files"],"requires":["i18n.lock file in project root (auto-generated on first run)","Version control (git) to track lock file changes"],"input_types":["Source content files","Previous i18n.lock manifest"],"output_types":["Updated i18n.lock manifest","List of changed/new strings requiring translation"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_2","uri":"capability://text.generation.language.runtime.sdk.for.dynamic.string.localization.with.fallback.chains","name":"runtime sdk for dynamic string localization with fallback chains","description":"Provides a JavaScript/TypeScript SDK (npm install lingo.dev) that localizes strings, objects, and HTML at runtime by querying a locale-aware translation store with automatic fallback chains (e.g., en-US → en → default). The SDK manages locale state, caches translations in memory, and supports both synchronous lookups for pre-compiled translations and async calls for dynamic content, with built-in support for pluralization and interpolation patterns.","intents":["I need to localize user-generated content or API responses at runtime, not just static strings","I want automatic fallback from regional locales (en-US) to base locales (en) to a default language","I need to switch locales dynamically without reloading the page or rebuilding"],"best_for":["applications with dynamic content requiring runtime translation (user-generated text, API responses)","projects supporting multiple regional variants of the same language (en-US, en-GB, en-AU)","teams needing locale switching without page reloads"],"limitations":["Runtime translation adds latency (~50-200ms per string depending on LLM provider) compared to pre-compiled translations","Memory caching can grow unbounded for high-cardinality dynamic strings; no built-in cache eviction policy","Fallback chains are linear and cannot be customized per string; all strings follow the same fallback hierarchy","No built-in support for context-specific translations (e.g., 'bank' as financial institution vs. riverbank)"],"requires":["Node.js 18+ or browser with ES2020+ support","API key for LLM provider (for dynamic translations)","npm package @lingo.dev/sdk"],"input_types":["strings","objects with string values","HTML strings"],"output_types":["localized strings","localized objects","localized HTML"],"categories":["text-generation-language","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_3","uri":"capability://automation.workflow.cli.with.multi.format.file.discovery.and.batch.translation.orchestration","name":"cli with multi-format file discovery and batch translation orchestration","description":"Command-line interface (npx lingo.dev@latest run) that recursively discovers translatable files in a project (JSON, YAML, CSV, PO, Markdown), batches them for efficient LLM processing, orchestrates the translation pipeline, and writes localized output files alongside an i18n.lock manifest. The CLI uses a configuration file (i18n.json) to define source directories, target locales, and provider settings, with support for dry-run mode and incremental translation (only translating changed files since last run).","intents":["I want to translate all my app's static content files in one command without manually specifying each file","I need to see what translations will be generated before committing them (dry-run mode)","I want to only re-translate files that have changed since my last translation run"],"best_for":["teams with large numbers of static content files across multiple directories","developers integrating i18n into local development workflows and CI/CD pipelines","projects needing reproducible, auditable translation runs with lock files"],"limitations":["File discovery is directory-based; no support for glob patterns or custom file filters beyond format type","Dry-run mode shows what will be translated but does not validate LLM output quality before writing","Incremental translation relies on file modification timestamps; can miss changes if files are copied or restored from version control","No built-in parallelization of LLM API calls; translation speed is limited by provider rate limits"],"requires":["Node.js 18+","i18n.json configuration file in project root","API key for LLM provider","npx or npm 7+"],"input_types":["i18n.json configuration file","Static content files (JSON, YAML, CSV, PO, Markdown)"],"output_types":["Translated static files","i18n.lock manifest","Console output with translation summary"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_4","uri":"capability://code.generation.editing.mcp.server.for.ai.agent.driven.i18n.configuration.and.routing","name":"mcp server for ai agent-driven i18n configuration and routing","description":"Exposes Lingo.dev as a Model Context Protocol (MCP) server that allows AI agents and IDEs to prompt for i18n needs in natural language and receive generated routing, middleware, and configuration boilerplate. The MCP server translates high-level i18n requirements (e.g., 'support 10 languages with fallback to English') into concrete code artifacts (Next.js middleware, locale routing, provider configuration) without requiring manual setup.","intents":["I want to describe my i18n needs in natural language and have an AI agent generate the boilerplate code","I need to quickly scaffold locale routing and middleware for a new multilingual project","I want an AI assistant to recommend the best LLM provider and configuration for my use case"],"best_for":["non-technical founders and product managers prototyping multilingual MVPs","developers using Claude, ChatGPT, or other MCP-compatible AI IDEs","teams wanting AI-assisted i18n setup without deep framework knowledge"],"limitations":["Generated boilerplate may require manual refinement for production use; no validation that generated code matches project structure","MCP server has no persistent state; each prompt is stateless and cannot reference previous configuration decisions","Limited to generating boilerplate; cannot modify existing code or integrate with live projects without manual copy-paste","AI-generated configuration may not follow project-specific conventions or best practices"],"requires":["MCP-compatible AI IDE or agent (Claude, ChatGPT with MCP plugin, etc.)","Lingo.dev MCP server running locally or accessible via network","Natural language description of i18n requirements"],"input_types":["Natural language prompts describing i18n needs","Project context (framework, target locales, provider preferences)"],"output_types":["Generated routing configuration","Generated middleware code","Generated provider configuration","Generated locale setup boilerplate"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_5","uri":"capability://automation.workflow.github.actions.ci.cd.integration.with.automatic.translation.on.push","name":"github actions ci/cd integration with automatic translation on push","description":"GitHub Action (uses: lingodotdev/lingo.dev@main) that triggers on git push to main, automatically translates changed content files, and commits translated files back to the repository or opens a pull request with translations. The action integrates with GitHub Workflows, caches translation results to avoid redundant API calls, and supports conditional triggers (e.g., only translate if specific files changed).","intents":["I want translations to happen automatically whenever I push content changes to main","I need translated files committed back to the repo without manual intervention","I want to review translations in a PR before merging them to main"],"best_for":["teams with continuous localization workflows integrated into CI/CD","projects where content updates and translations should stay in sync","organizations wanting to reduce manual translation overhead in development cycles"],"limitations":["Action runs on every push; no built-in cost controls for high-frequency commits with many translatable strings","GitHub Actions have 6-hour job timeout; very large translation batches may exceed limits","Commit-back or PR creation requires write access to repository; may conflict with branch protection rules","No built-in approval workflow; translations are committed/PRed without human review by default"],"requires":["GitHub repository with Actions enabled","GitHub token with write access (for committing or creating PRs)","API key for LLM provider (stored as GitHub secret)","i18n.json configuration file in repository"],"input_types":["Git push events","Changed files in commit","i18n.json configuration"],"output_types":["Commit with translated files","Pull request with translations","GitHub Actions workflow logs"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_6","uri":"capability://memory.knowledge.locale.management.with.hierarchical.fallback.chains.and.regional.variants","name":"locale management with hierarchical fallback chains and regional variants","description":"Manages locale hierarchies and fallback chains (e.g., en-US → en → default) at both compile-time and runtime, allowing applications to support regional language variants without duplicating translations. The system tracks which locales are configured, validates locale codes against IANA standards, and automatically generates fallback paths for missing translations, reducing the number of unique translation strings needed.","intents":["I want to support en-US, en-GB, and en-AU without translating the same strings three times","I need to automatically fall back to a base language if a regional variant is missing","I want to validate that my configured locales are valid IANA language codes"],"best_for":["applications supporting multiple regional variants of the same language","teams wanting to minimize translation costs by reusing base language translations","projects with complex locale requirements (e.g., Simplified Chinese, Traditional Chinese, regional variants)"],"limitations":["Fallback chains are linear and cannot be customized per string; all strings follow the same hierarchy","No support for script-specific fallbacks (e.g., zh-Hans → zh-Hant); only language and region fallbacks","Locale validation is basic; does not check if a locale is actually supported by the chosen LLM provider","No built-in support for deprecated locale codes or historical locale migrations"],"requires":["i18n.json configuration with locales array","IANA-compliant locale codes (e.g., en-US, zh-Hans, pt-BR)"],"input_types":["Locale configuration in i18n.json","Locale codes in source files"],"output_types":["Fallback chain definitions","Locale validation results","Locale-specific translation files"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_7","uri":"capability://data.processing.analysis.format.specific.file.loaders.with.structure.preserving.parsing","name":"format-specific file loaders with structure-preserving parsing","description":"Implements pluggable file format loaders for JSON, YAML, CSV, PO (gettext), and Markdown that parse files into an intermediate representation, extract translatable strings while preserving file structure, metadata, and formatting. Each loader uses format-specific parsing (JSON.parse, YAML parser, CSV reader, PO parser, Markdown AST) to maintain round-trip fidelity, ensuring that translations can be written back to the original format without losing structure or comments.","intents":["I want to translate my JSON config files without losing comments or structure","I need to extract translatable strings from Markdown documentation while preserving headings and formatting","I want to translate CSV data files while keeping column structure intact"],"best_for":["projects with diverse content file formats (JSON, YAML, CSV, PO, Markdown)","teams needing to preserve file structure and metadata during translation","applications where translation round-trip fidelity is critical (e.g., configuration files, documentation)"],"limitations":["Custom file formats not supported; only JSON, YAML, CSV, PO, Markdown are built-in","Nested structures in JSON/YAML are flattened to strings; complex objects cannot be translated","CSV parsing assumes simple tabular structure; no support for complex CSV dialects or multi-line cells","Markdown translation only handles text content; code blocks and metadata are not translated"],"requires":["Files in supported formats (JSON, YAML, CSV, PO, Markdown)","Format-specific parser libraries (included in @lingo.dev/sdk)"],"input_types":["JSON files","YAML files","CSV files","PO (gettext) files","Markdown files"],"output_types":["Parsed intermediate representation","Extracted translatable strings","Translated files in original format"],"categories":["data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_8","uri":"capability://automation.workflow.monorepo.architecture.with.turborepo.caching.and.pnpm.workspaces","name":"monorepo architecture with turborepo caching and pnpm workspaces","description":"Organizes Lingo.dev as a pnpm + Turborepo monorepo with layered package dependencies (foundational packages like @lingo.dev/_locales and @lingo.dev/_spec have no internal dependencies, while CLI sits at the top consuming everything). Turborepo caching accelerates builds and tests by caching task outputs, while pnpm workspaces enable efficient dependency management and code sharing across CLI, SDK, compiler, React, and spec packages.","intents":["I want to contribute to Lingo.dev without rebuilding all packages every time","I need to understand how the CLI, SDK, compiler, and React packages depend on each other","I want to publish updates to individual packages without affecting others"],"best_for":["contributors and maintainers of Lingo.dev","teams forking or extending Lingo.dev with custom packages","developers understanding the internal architecture for debugging or optimization"],"limitations":["Monorepo complexity adds overhead for simple use cases; users only need the CLI or SDK, not the full monorepo","Turborepo caching requires careful task definition; misconfigured tasks can lead to stale cache hits","pnpm workspaces require pnpm 7+; npm or yarn users must install pnpm separately","Cross-package changes require coordinated version bumps and changelog updates"],"requires":["pnpm 7+","Node.js 18+","Turborepo (installed as dev dependency)"],"input_types":["Package source code","Task definitions in turbo.json"],"output_types":["Built packages in dist/ directories","Cached task outputs","Published npm packages"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"awesome-lingo-dev__cap_9","uri":"capability://data.processing.analysis.configuration.driven.i18n.pipeline.with.i18n.json.schema","name":"configuration-driven i18n pipeline with i18n.json schema","description":"Defines a declarative i18n.json configuration file that specifies source directories, target locales, LLM provider settings, file format filters, and translation rules. The configuration schema is validated at runtime, allowing users to control the entire translation pipeline (which files to translate, which locales to target, which provider to use) without code changes. Configuration is shared across CLI, compiler, and SDK, ensuring consistency across all product surfaces.","intents":["I want to define my i18n setup once and have it work across CLI, build, and runtime","I need to switch LLM providers without changing code","I want to exclude certain files or directories from translation"],"best_for":["teams wanting declarative, version-controlled i18n configuration","projects with complex localization requirements (many locales, multiple providers, selective file translation)","organizations needing to audit and review i18n settings"],"limitations":["Configuration schema is fixed; no support for custom configuration formats or extensions","No built-in validation of LLM provider credentials; invalid API keys are only caught at runtime","Configuration changes require rerunning the CLI or rebuilding; no hot-reload for configuration updates","No support for environment-specific configurations (dev, staging, prod); single i18n.json for all environments"],"requires":["i18n.json file in project root","Valid JSON syntax","Configured locales and source directories"],"input_types":["i18n.json configuration file"],"output_types":["Validated configuration object","Configuration errors or warnings"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":31,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+","API key for at least one LLM provider (Lingo.dev Engine, OpenAI, Anthropic, Google, Mistral, OpenRouter, or Ollama)","Static content files in supported formats (JSON, YAML, CSV, PO, Markdown)","Next.js 13+ or Vite 4+ or webpack 5+","React 16.8+ (for hooks support in compiled components)","TypeScript 4.5+ (optional but recommended for type safety)","API key for LLM provider","React 16.8+","npm package @lingo.dev/react","Lingo.dev SDK (@lingo.dev/sdk)"],"failure_modes":["Translation quality depends entirely on the chosen LLM provider; no built-in quality gates or human review workflows","Large translation batches may incur significant LLM API costs; no cost estimation or budgeting built-in","i18n.lock manifest can become stale if translations are modified outside the CLI/compiler pipeline","No support for context-aware translation hints (e.g., 'this button label should be <10 chars')","Requires build-time LLM API calls, which can slow down CI/CD pipelines for large projects (100+ translatable strings may add 30-60s per build)","Dynamic string translation (runtime user input) not supported; only static JSX strings are compiled","Legacy compiler (@lingo.dev/_compiler) is deprecated; migration to new compiler required for new projects","Source map generation adds ~10-15% to build time; can be disabled for production if needed","React package is React 16.8+ only (requires hooks support); no support for class components","Context-based locale switching causes all subscribed components to re-render; no fine-grained update control","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.49,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:03.577Z","last_scraped_at":"2026-05-03T14:00:15.503Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=lingo-dev","compare_url":"https://unfragile.ai/compare?artifact=lingo-dev"}},"signature":"+F3FvxT4AGuS2yfpS+jX26OwDunh7DKAUh0ucykSTO2D6HtdQoKUW2J0cHTMDpEAX74K8OUK2xS/HFvkV15sDA==","signedAt":"2026-06-22T05:08:59.200Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/lingo-dev","artifact":"https://unfragile.ai/lingo-dev","verify":"https://unfragile.ai/api/v1/verify?slug=lingo-dev","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}