Supercharge your AI with Text Diff Engine. Generate absolute patches for code and contracts.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Text Diff Engine compares text versions character-by-character and line-by-line to generate absolute patch files. It bypasses LLM summarization, giving you deterministic diff outputs for code patches, legal contracts, or structured data.
Stop guessing what changed; see the exact additions (+), deletions (-), and unchanged lines between any two strings.
What your AI can do
Compare texts
Performs an exact line-by-line diff comparison between two strings, returning a structured report of additions, deletions, and context lines.
Pass two text strings (original and modified) to get a structured report detailing every addition, deletion, and context line.
The tool pinpoints specific character-level edits, useful when tracking minor syntax alterations in configuration files or source code.
Output standardized diff formats (like those used in Git) that can be directly applied to patch versions of documents.
Ask an AI about this
Compatible AI Apps
OAuth 2.0 Compatible Gemini Waiting for input…
Text Diff Engine MCP Server: 1 Tool for Comparison
Use this single tool to compare any two text inputs—code, documents, or configs—and generate structured patch files showing exactly what changed.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Text Diff Engine on VinkiusCompare Texts
Performs an exact line-by-line diff comparison between two strings, returning a structured report of additions, deletions, and context...
Connect to your AI in seconds. Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token from
cloud.vinkius.com. For OAuth-protected servers, expand Advanced
settings to add credentials.
Start a conversation
Open a new chat. The Text Diff Engine integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Text Diff Engine, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,000+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Diff Library. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 1 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manually tracking document changes takes forever.
Today, checking for differences involves tedious copy-pasting into comparison websites or running complex CLI commands. You open one file in a text editor, paste the old version; then you do it again with the new version. If the document is large—like a multi-page contract—you're spending time manually cross-referencing line numbers and trying to isolate if a single comma was added or removed.
With this engine, that manual labor vanishes. You feed the agent both versions, and it runs `compare_texts`. The result isn't an article; it’s a structured diff showing every addition (`+`) and deletion (`-`). It’s immediate, accurate, and ready for review.
Text Diff Engine MCP Server: see exact patches in seconds.
The biggest time sink was the back-and-forth: 'Hey, did you add this section?' followed by having to manually verify which paragraph it was. You were spending cognitive cycles confirming trivial changes when you should be focusing on the actual content.
Now, your agent runs `compare_texts` and immediately provides a unified diff block showing exactly what changed in lines 45-52. The process moves from hours of comparison to seconds of verification.
What your AI can actually do with this
When you're dealing with version control, relying on a large language model to summarize what changed? Nah. Those things just give you a narrative; they don't show you the actual mechanics. You need to know how it flipped—not just that it did. This Text Diff Engine fixes that mess. It ditches the guesswork and gives you deterministic, structured patches for any text input, whether it’s code or some dense legal contract.
The compare_texts tool performs an exact line-by-line diff comparison between two strings, spitting out a structured report of additions, deletions, and context lines that tells you exactly what's up. It takes the original version and the modified version, runs the comparison, and returns a detailed breakdown: everything added gets marked with +, anything removed shows up with -, and context lines—the bits that didn’t move—are kept intact.
You can use this engine to generate structured line-by-line diffs by passing two text strings (original and modified) to get a report detailing every change. It doesn't just tell you if something changed; it shows the full record, which is crucial for reliable code review and compliance checks on legal documents.
Because of this granular control, you can pinpoint specific character-level edits, making it perfect for tracking minor syntax alterations in configuration files or source code where a single comma matters.
Beyond simple line comparison, you'll get the ability to create unified diff patches. This means the output is standardized in formats like those used by Git, allowing you to apply these changes directly as patch versions of documents. You feed it two texts, and you walk away with a formal set of instructions for applying the difference.
This engine’s purpose is simple: it guarantees determinism. It gives you an absolute record when your workflow demands precision—whether you're migrating structured data like JSON or XML, or just need to prove exactly what got scrubbed out of a policy document. You don't get vague summaries; you get the precise mechanics.
Use this tool when "it looks right" isn't good enough; you gotta see the exact additions and deletions.
019e38f9-92a7-72eb-b8ed-795ae6dccde2 
Here's how it actually works
The bottom line is: it gives you absolute truth about text changes, regardless of how complex or subtle they are.
You send the tool two text inputs: the 'Original' content and the 'Modified' content.
The engine processes both strings using the internal diff library, mapping every character divergence.
It returns a structured output showing additions (+), deletions (-), and unchanged lines in clear patch format.
Who is this actually for?
This tool belongs to the developer, legal analyst, and ops engineer who can't trust a vague AI summary. If your job requires proving exactly what changed in a codebase or contract—down to the single comma—you need this. It solves the 'Did it actually change?' problem.
Uses compare_texts during code review to generate precise patches for pull requests, ensuring no attribute or line of logic was accidentally dropped.
Compares draft versions of contracts side-by-side to flag every single word addition or removal in clauses, guaranteeing compliance tracking.
Validates configuration file changes (e.g., YAML, JSON) between environments to ensure only intended keys and values were updated.
What Changes When You Connect
Deterministic Output: Instead of getting a narrative summary, compare_texts gives you structured diffs. This means the output is purely technical data you can trust—it’s reliable, repeatable truth.
Code Integrity: When reviewing JSON or config files, you need to know if an attribute was dropped or changed its value. The engine flags these structural shifts instantly, which simple LLM prompts often miss.
Legal Precision: For contracts and regulatory documents, vague summaries are useless. You use compare_texts to guarantee that every single word added or removed is visible for compliance checks.
Version Control Compliance: It functions as a dedicated diff library, allowing you to compare file versions (like HTML minification) to confirm structural identity despite whitespace changes.
Bypasses AI Guesswork: You're not relying on an agent's best guess. The engine uses the diff library directly, providing raw, verifiable data that is 100% accurate.
See it in action
Reviewing a JSON Schema Update
A DevOps engineer updates a service's environment configuration from v1 to v2. Instead of pasting the files and asking an AI agent what changed, they run compare_texts. The tool immediately isolates that the 'database_port' was changed from 5432 to 6000, and no other critical keys were modified. This prevents deployment errors.
Tracking Legal Clause Revisions
A legal analyst receives a revised non-disclosure agreement (NDA). They use compare_texts on the original and new versions. The tool highlights exactly where 'Indemnification' was added, and which specific paragraph defining 'Confidential Information' was deleted, making compliance review straightforward.
Comparing HTML Minified vs. Original Code
A frontend developer needs to confirm that minifying an HTML file didn't strip any necessary attributes or unique class names. Running compare_texts confirms the files are structurally identical, showing only whitespace differences—a clean pass.
Patching a Multi-File Codebase
A software team rolls out an update that affects three interconnected source code files. Instead of manually tracking changes across Git commits, they use compare_texts on the old and new versions of each file to generate clean, unified diffs for immediate patching.
The honest tradeoffs
Asking an LLM to 'Summarize differences'
Pasting two complex legal contracts into a general chat model and asking it, 'What changed here?' The result is vague prose that says things like, 'The agreement has been updated regarding termination rights.' You don't know if the clause was removed or just rephrased.
Use compare_texts instead. It forces a line-by-line comparison and outputs markers showing exactly which lines were added (+) and which were deleted (-), giving you verifiable proof of change.
Assuming simple text matching is enough
Comparing two JSON files that are identical in meaning but formatted differently (e.g., different key order or spacing). A basic comparison might fail to highlight all structural differences.
The engine provides a deterministic diff, handling both semantic and structural changes across fields, ensuring you catch even subtle formatting shifts necessary for data integrity.
Using the wrong tool for version control
Relying on manual Git history browsing when you only need to compare two specific files at a given time. This is slow and requires multiple context switches.
Use compare_texts directly within your agent workflow. You feed it the two versions, and the engine returns the clean diff output in one step, bypassing the Git CLI entirely.
When It Fits, When It Doesn't
Use this MCP Server if you absolutely need a verifiable, mechanical record of text changes—if 'vague' is not an acceptable answer. Think code patches, legal compliance audits, or data migration validation. It’s your go-to tool when the difference between two files must be visible line by line.
Don't use it if you just need general context or high-level takeaways. If you're asking an AI agent to 'Explain what this change means for our business strategy,' then a simple LLM prompt is fine. This tool only gives the raw data; your AI client has to interpret it. It provides the mechanical evidence, not the strategic insight.
Questions you might have
How does Text Diff Engine compare text versions? +
It uses a deterministic diff library, not an LLM summary. You provide two strings (original and modified), and the engine generates structured patches showing additions (+) and deletions (-).
Is the output from compare_texts useful for code review? +
Absolutely. The unified diff format it provides is standard in version control systems, making it immediately usable by engineers who need to see exactly what was added or changed.
Can I use Text Diff Engine for comparing JSON files? +
Yes. While you pass the content as text strings, it handles structural differences in data formats like JSON and XML reliably, ensuring attribute loss is flagged.
Does Text Diff Engine handle whitespace changes? +
Yes. It's designed to detect both functional changes and cosmetic ones. It can report if only whitespace was removed or added, which is critical for minification checks.
What is the character limit when running compare_texts? +
The tool handles large texts efficiently, supporting inputs of significant length without hitting memory limits. It's built to manage full documents or long codebases, so don't worry about standard document size constraints.
Does the output from Text Diff Engine provide a structured format? +
Yes, the output is highly structured for easy parsing. Instead of just plain text, it returns distinct sections detailing additions, deletions, and unchanged lines in a format your agent can consume directly.
What happens if I pass non-text data to compare_texts? +
The tool validates inputs before processing. If the original or modified versions aren't valid strings, it returns a specific error message and status code, allowing your agent to handle the failure gracefully.
Are there any rate limits I should know about when using Text Diff Engine? +
Rate limits are managed by Vinkius Marketplace. For standard usage through your AI client connection, you'll operate under established service quotas. Check the server dashboard for real-time usage metrics.
Can it diff code? +
Yes, it is excellent for comparing code files.
Does it output in standard patch format? +
Yes, it outputs unified diff formatting.
Can it diff large documents? +
Absolutely, it runs instantly on large text payloads.
We've already built the connector for Text Diff Engine. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 1 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.