MiniMax M2 Local AI Knowledge Base Test: Source Tracing, Deduplication, and Fact Verification

In the Age of Information Overload, We Need Source Tracing — Not Just Summaries

The biggest pain point in AI content work is no longer finding resources — it's that there are far too many. Every day brings new models, new tutorials, new benchmarks, and new product launches. Official channels claim state-of-the-art performance. Media outlets say a model is a Claude alternative. Bloggers rave about how great it is. Then the comments section lights up with people saying their actual experience was completely different.

You've seen all of this information — but after a while, you're left with only a vague takeaway: "that model seems pretty capable." Whether that conclusion came from an official claim, a media report, a benchmark, or one user's personal experience? Long forgotten.

This kind of forgetting isn't accidental. Psychology researchers call it the Source Confusion Effect: within 72 hours of receiving information, people tend to retain the conclusion while losing the source — unable to distinguish between firsthand verification and hearsay. Sociologist Alvin Toffler described this "information overload" phenomenon systematically as early as 1970 in Future Shock — as the volume of information increases, the density of useful information actually decreases, creating what knowledge management calls an "information entropy" trap.

What makes this even more complicated is how fast the AI field moves. Something that was a launch discount last month may be back to full price now. A platform that only offered 512K context may have since upgraded to 1 million tokens. This raises a central question: can a large language model take messy articles, PDFs, course subtitles, screenshots, or personal notes and organize them into a local knowledge base — not just as a summary, but one that tracks who said what, whether it's a fact or an opinion, whether there's a conflicting view, and whether the information might already be outdated?

Project Architecture: Building a Knowledge System with M2 Inside OpenCode

The tech stack for this experiment is quite representative: MiniMax M2 runs inside the OpenCode agent framework, directly designing rules, building structures, and processing materials in a local folder — then feeding the results into Obsidian as a visual frontend. The actual data being processed is a set of local Markdown files, but Obsidian makes it easy to browse tags, bidirectional links, indexes, and a knowledge graph.

OpenCode is an open-source terminal AI coding assistant framework. Its core mechanism is Tool Calling — the model doesn't just generate text; it can call tools like file read/write, terminal commands, and code execution to complete multi-step tasks. This follows the ReAct (Reason + Act) paradigm: at each step, the model first reasons, then acts, dynamically adjusting strategy based on environmental feedback. This makes it capable of handling open-ended tasks with fuzzy boundaries, like "build a knowledge system."

The real test here isn't whether M2 can write code — it's whether it can take a vague idea and turn it into a functioning, iteratable knowledge system. This demands three things from the model: long context, strong comprehension, and native multimodality. And the price can't be too steep — this system is constantly reading new materials and comparing them against existing entries, consuming a significant number of tokens.

Start with a Knowledge Map

When learning a new domain, people don't start by cramming everything into their heads — they first form a rough map. That's the approach here: let M2 build a tagging and folder system for the knowledge base, framing the entire information space first.

This wiki focuses on a few categories: AI models, agents, developer tools, companies, key figures, papers, and web coding-related content. The file structure is inspired by the "Second Brain" concept — a personal knowledge management (PKM) methodology developed by Tiago Forte, centered on the PARA system (Projects/Areas/Resources/Archive). Obsidian is its most popular implementation tool, building a non-linear knowledge network via bidirectional links (Backlinks) and local Markdown files. All files can be read and written directly by scripts, making it a natural fit for AI Agent integration.

The file structure is kept simple: raw stores original materials, wiki stores organized knowledge pages, source records references, index generates topic indexes, logs tracks each import and modification, and dashboard displays recent updates, conflict flags, and items needing review.

If you dump dozens of materials to the model all at once and let it run free, it will likely generate pages that look complete but are actually a mess. Building the map first is exactly how you avoid creating an information junkyard.

Distinguishing Facts from Opinions: The Most Critical Capability of a Knowledge Base

The most important design principle of this system is: not all text should be treated as the same type of information.

In information science, the practice of tiering information by credibility and source is called Source Hierarchy. It's highly mature in evidence-based medicine, forming a pyramid model that ranges from randomized controlled trials down to expert opinion. Journalism has a similar concept — the Three-Source Rule: information from a single source should not be treated as confirmed fact. Applying this thinking to AI knowledge management means strictly distinguishing between: primary sources (official documentation, papers), secondary sources (media reports, evaluations), and tertiary sources (personal opinions, social media).

Here's a concrete example: an official document states that "a model's coding ability has reached SOTA." If you just ask AI to summarize it, it will write in the wiki: "This model is the SOTA in coding." But those two statements are completely different things.

A more accurate record should read: "The model's developer officially claims its coding capabilities are top-tier," with annotations indicating whether the source is an official claim or a third-party conclusion, whether it has been independently verified, and which version and time period it applies to. Timing is especially important — a model that was SOTA three months ago may have already fallen behind.

Similarly, when a YouTube creator says "this tool is great for large projects," that cannot be converted into objective fact. The system should record it as an opinion offered by that creator based on personal experience.

The types of information the system needs to distinguish include:

• Official statements
• Media reports
• Third-party evaluations
• User opinions
• Personal notes
• Facts directly supported by source materials

A good knowledge base should preserve not just conclusions, but the context in which those conclusions were formed — it shouldn't pretend to know the truth for you; it should tell you who said it.

Deduplication and Restraint: The Hardest Thing for AI Is Not Generating New Content

One of the hardest parts of the entire system is deduplication. For this experiment, multiple materials discussing the same model were prepared intentionally: a course, an influencer review, official documentation, and personal notes. If each import created a new page, the wiki would quickly become another information junkyard.

The right approach is to first identify the subject — determining whether different names all point to the same thing (e.g., all referring to Claude Code). If a page already exists, new material should be merged into it while preserving each source separately.

What's being tested here isn't keyword matching, but whether the model can understand: which pieces of content are simply supplements to the same subject, and which genuinely deserve to be independent entries. M2 is asked to evaluate duplication based on titles, aliases, object types, and context together. This process yields a powerful insight:

AI is very good at generating new content. The truly hard part of a knowledge system is restraining itself from constantly generating new content.

Preserve Conflicts — Don't Pick Sides for the User

A lot of information online isn't simply right or wrong. For instance, one source says a model supports 1 million tokens of context, while another platform's documentation says only 512K is guaranteed. These seem contradictory — but both could be true. One describes the theoretical maximum; the other describes the practical limit of a specific API.

Similarly, one user might say a certain coding agent is great for long autonomous tasks, while another says it tends to go off the rails on large projects and requires frequent human intervention. When the system encounters these two views, it should not delete one of them, and it should not pick sides. Instead, it should preserve both, record their sources, and attempt to explain that this may reflect differences in project scale, usage patterns, or model versions.

As the saying goes: "The mark of a first-rate intelligence is the ability to hold two opposing ideas in mind at the same time while retaining the ability to function." This wiki should have a similar capability — it doesn't need to decide who's right, but it should at least flag that a conflict exists and warrants further judgment.

Timeliness Management: Knowledge Has an Expiration Date

A lot of information in the AI field has a shelf life. Many models launch with limited-time discounts — if the wiki simply records "API currently at 50% off," that entry could be completely wrong a month later.

To address this, the system adds temporal attributes to information: when it was acquired, whether there's a stated expiration date, and when it was last verified. When subsequent materials reflect changes, the system should not simply overwrite old content — it should preserve the old record and generate a Change Log. This way, the wiki isn't just a repository for information; it also tracks how knowledge evolves over time. Given enough time, you can even trace the full development arc of a given topic.

Multimodal Test: Reading a Benchmark Screenshot

Finally, a benchmark screenshot was fed into the system. For AI knowledge organization, the key capability of multimodality isn't getting the model to describe what's in an image — it's whether the model can read a complex table, extract model names, metrics, and pricing, write that data into the corresponding wiki pages, and factor it into judgments alongside text-based materials.

The technical difficulty here goes far beyond "image captioning." Multimodal large models use a Vision Encoder (typically based on the ViT architecture) to transform images into vector representations compatible with text, which are then fed into the language model. For benchmark screenshots, the model must simultaneously exercise three capabilities: OCR (optical character recognition), table structure understanding, and semantic alignment — not only recognizing the numbers, but understanding the row-column relationships and metric meanings, then mapping them to the corresponding model entries in the existing knowledge base.

After several iterations, the originally blank Obsidian vault became a browsable local knowledge base: explorable by tools, models, concepts, papers, and other topics. Opening any page reveals related articles, courses, and evaluations. Important opinions retain their sources, conflicting information is flagged separately, and time-sensitive content like pricing and versions appears in a review queue.

Chat-based Q&A was intentionally left out, as that involves retrieval, ranking, and RAG — a completely separate project. RAG (Retrieval-Augmented Generation) is the dominant architecture for AI knowledge systems today, first proposed by Meta in 2020. Its core workflow involves chunking documents into vector embeddings stored in a vector database, then retrieving relevant segments at query time before passing them to an LLM to generate answers. This encompasses chunking strategy, similarity ranking, context window management, and a full set of independent engineering challenges — a different system layer from knowledge organization itself. For basic information retrieval, Obsidian's built-in search, tags, indexes, and bidirectional links are more than sufficient.

Conclusion: The Convergence of Agent, Long Context, and Multimodality

After completing this project, the most interesting thing about MiniMax M2 is that agent capabilities, long context, and multimodality can flow naturally together within a single workflow.

What was given to M2 wasn't a neatly scoped small task — it was a fairly brief description. The model had to break it down on its own: defining the file structure, designing the rules, re-examining the wiki after discovering duplicate pages, adjusting the deduplication logic, and continuing to iterate.

The value of long context here isn't "loading dozens of documents at once without missing anything." It's that when M2 processes a new piece of material, it can simultaneously understand the current rules, existing wiki entries, source cards, and indexes — then determine whether this new information is genuinely new or just a supplement to something already there. Technically, this depends on efficient attention mechanisms like Flash Attention to optimize computation over long sequences. Early GPT-3 supported only 4K tokens, while million-token context windows make cross-document consistency reasoning possible: when processing the 50th document, the model can still precisely recall the rules and conclusions established across the previous 49, avoiding contradictory knowledge entries.

Of course, this system is not a finished product: source judgment and update mechanisms still need improvement, and longer materials require segmented processing and human review. But this experiment at least proves: the value of a real AI knowledge system lies not in how much content it generates, but in whether it can honestly tell you — who said this, how credible is it, and has it expired.

Key Takeaways