Transcription
As AI-assisted coding becomes more popular, we've noticed a major issue: AI models struggle with generating accurate, version-specific code for libraries and frameworks. That's why we built Anchoring, a desktop application that helps solve this problem. Anchoring allows you to crawl documentation websites for your programming technologies, convert that content into a clean format, and create a searchable knowledge base of version-accurate documentation. When integrated with tools like Claude or Cursor using the built-in mCP server, Anchoring provides version-specific, context-aware documentation that helps AI assistants generate code that actually works for your specific environment.
This is version 0.1.0, and I'm excited to share this free, open-source tool with you. Let me give you a quick demonstration of how it works. First, I'll go to the settings tab and refresh the list of proxy servers. This feature is crucial because it prevents rate limiting when crawling documentation sites. You can see it loaded over 2,400 proxies that automatically update daily. Now, I'll enter my OpenAI API key and save the settings. This key is used by GPT-40 mini later to process the documentation we crawl.
Let's create a new session for Tari v2. I'll name it "Tari V2" and add version 2.3.1 as a reference. This session naming and optional version field helps me organize different documentation crawling projects. Next, I'll enter the main documentation URL for Tari V2 and save the configuration. Now, I'll add this URL as our starting point and check the option to only crawl URLs with pending status. When I start the crawler, watch how quickly it discovers new URLs. The application intelligently follows links within the documentation, automatically building a comprehensive map of all available resources. This automated discovery is what makes the tool so efficient at gathering complete documentation.
One of the most powerful features is the ability to filter out irrelevant content using anti-patterns. Let me demonstrate this. I'll add keywords like "blog," "release," and the pound sign to our anti-patterns list. Blog posts, while informative, aren't exactly documentation snippets that would be useful for AI code generation. The release paths contain links to documentation for different versions, which we want to avoid to prevent the knowledge base from being polluted with mixed-version documentation. URLs with hash symbols typically just point to sections within pages we've already captured, so filtering those prevents duplicate content. When I save this configuration and apply the filters, you can see the URL count drops dramatically, from over 1,400 to just 167. This focused approach ensures only the most relevant documentation makes it into our knowledge base, which significantly improves the quality of AI-generated code by eliminating noise from the data set.
Here, I'm showing the terminal logs that reveal what's happening behind the scenes. Notice how the application converts HTML to Markdown, typically reducing the character count by 70% or more. This isn't just about clean formatting; it significantly reduces costs when we send the content to GPT-40 mini for processing, since every token counts toward your API costs. All the heavy lifting—the web crawling, HTML processing, and Markdown conversion—happens on the Rust side of the Tari application for maximum efficiency and performance. This hybrid approach gives us the best of both worlds: a modern React interface with the raw processing power of native code. You can also see the Headless Chrome instance automatically scrolling through pages to trigger any lazy-loading elements. This ensures we capture all the documentation, even content that only appears when you scroll down the page.
Now that we've completed our crawl, let's take a look at what we've gathered. I'll click on the biometric plug-in results to preview the content. Here, you can toggle between the raw HTML view and the converted Markdown. This transformation is crucial; it strips away styling, scripts, and navigation elements while preserving the actual documentation content. This clean Markdown is what we'll send to our AI processing pipeline in the next step.
Next, I'll head to the AI processing tab, where we transform raw documentation into structured knowledge. I'm selecting the Tari SQL plug-in and clipboard plug-in pages to process. Notice these configuration options: you can enable unlimited parallelization to process multiple documents simultaneously and adjust the temperature setting to control the AI's creativity level when processing content. When I click "Start processing," GPT-40 mini performs a two-stage operation. First, it cleans up the Markdown to focus on the essential documentation content. Then, it processes this cleaned text to create structured documentation snippets using Zod schemas. Each snippet gets a title, description, the code example itself, and a list of relevant concepts that help with semantic search later.
Now that processing is complete, let's see the power of our knowledge base in action. Here are the generated snippets for the Tari SQL plugin. Notice how they're cleanly organized by functionality. The real magic happens when we move to the knowledge base tab and perform a natural language search. I'll type, "How do I use the Tari 2.3.1 clipboard functionality on the TypeScript side?" Look at the results: the top match has an 80% similarity score and contains exactly what we need: the clipboard plug-in overview with TypeScript examples, installation instructions via npm, required Tari permissions, and even the Rust implementation details. This is version-specific documentation that matches exactly what we asked for. And since Anchoring automatically installs, calls, and runs an mCP server for you, tools like Claude and Cursor can directly access this knowledge base to generate code that's perfectly tailored to your environment. No more retrofitting examples or fixing version mismatches. AI assistants now understand your exact library versions and can generate code that works right away.
Now let's see how this all comes together with a real coding task, with and without Anchoring. I'll open a React component that uses Tari's invoke method and show you what happens in both scenarios. First, without Anchoring: in Cursor settings, you can see I've disabled the Anchoring mCP server. Now I'll delete the line importing the invoke function and ask Cursor to fix the resulting error. Watch what happens. Cursor suggests to import `invoke` from `tar-apps/api/tari`, which is outdated syntax for Tari v2. Even when it encounters linting errors, it doesn't understand the real problem. Instead, Cursor says I need to install the Tari API package. Let me check if it's already in the `package.json` first. It concludes, "I found the issue: the `tar-app/API` package is installed, but only as a dev dependency. Let's run the installation command to add it as a regular dependency." Cursor is trying to reinstall a package we already have because its knowledge is outdated. After installation, it believes the problem is fixed, but the syntax error remains.
Now let's see what happens with Anchoring. I'll enable the mCP server and apply our system Cursor rules file. When I delete the same import line and ask Cursor to fix it, the difference is dramatic. Cursor immediately calls the mCP server to check what libraries are available, identifies our Tari 2.3.1 version, and queries for the correct invoke function syntax without hesitation. It generates the correct code on its first try. When I click on the mCP query results, you can see Anchoring provided the exact API plug-in snippet that explains the current invoke function usage and syntax. Cursor implemented the fix perfectly on the first try, with no trial and error or outdated information. This is the power of version-specific documentation: AI assistants can provide accurate solutions immediately, rather than struggling with outdated knowledge.
As you can see, Anchoring is just the beginning of a much larger vision. In the coming weeks, we'll be launching a platform that partners directly with library maintainers to automate this entire process. The key innovation will be providing version-specific accuracy for any library version, allowing AI coding assistants to work with the latest releases the moment they're available, completely overcoming knowledge cutoff dates that limit current AI models. What's exciting for library maintainers is our revenue-sharing model: when AI platforms use your documentation snippets through our API, you'll receive a share of that revenue. This transforms documentation from a burden into an income source, especially valuable for open-source projects. If you maintain a library and are interested in joining our early partner program, or if you're a developer who finds Anchoring helpful, I'd love to hear from you as we build this bridge between AI and accurate code generation.