How to Build an OKF Knowledge Bundle: Share Your AI Knowledge Base with Any Agent
Google's Open Knowledge Format lets you package knowledge bases as shareable bundles. Learn how to build one and import it into your second brain.
What Is an OKF Knowledge Bundle and Why Should You Care?
Knowledge is only useful if the right system can access it at the right time. As AI agents become more specialized and numerous, the problem of getting your knowledge base into each one — consistently, accurately, and without rebuilding from scratch — is becoming a real bottleneck.
That’s where Google’s Open Knowledge Format (OKF) comes in. An OKF knowledge bundle is a portable, structured package of your AI knowledge base: documents, FAQs, structured data, metadata, and configuration — all bundled together so any compatible AI agent can consume it without manual re-entry.
If you’ve been building separate knowledge bases for different tools or spending hours re-uploading the same documents into new AI workflows, this guide is for you. We’ll walk through what an OKF knowledge bundle contains, how to build one, and how to share it with the AI agents and systems you rely on.
Understanding the Open Knowledge Format
What OKF Actually Is
OKF is a specification for packaging knowledge assets into a portable, machine-readable bundle. Think of it as a container format — like a ZIP file, but structured specifically for AI consumption. The goal is interoperability: you build your knowledge base once, export it as an OKF bundle, and any agent that supports the format can import and use it immediately.
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
The format emerged from the broader push toward AI knowledge portability. As organizations deploy more agents across more workflows, duplicating knowledge becomes unsustainable. OKF addresses this by standardizing how knowledge is structured, referenced, and shared.
What Goes Inside a Knowledge Bundle
An OKF bundle typically contains several layers:
- Source documents — PDFs, markdown files, text documents, web pages, or structured data files
- Metadata — Tags, categories, creation dates, authorship, and access permissions
- Chunking configuration — Instructions for how the knowledge should be split when it’s retrieved
- Embedding hints — Optional pre-computed embeddings or guidance on which embedding model to use
- Retrieval schema — Rules for how the agent should query and rank results
- A manifest file — An index that describes everything in the bundle and how it fits together
The manifest is the most important piece. It tells any importing system what’s in the bundle, how it’s organized, and what parameters to apply when using it.
Why Standardization Matters Here
Without a standard format, every tool has its own knowledge base structure. You upload documents to Notion, a separate set to your chatbot platform, another batch to your internal wiki, and so on. When an AI agent needs to reference company policies, it only knows what you’ve explicitly given it in that specific system.
OKF breaks that pattern. A single well-built bundle can be imported into multiple agents, ensuring consistent knowledge access regardless of which tool is running the query.
Before You Build: What Makes a Good Knowledge Base
A knowledge bundle is only as useful as the knowledge inside it. Before you start packaging anything, you need clean, well-organized source material.
Audit What You Already Have
Start by listing every document, FAQ, process guide, or reference file that your agents should know about. Common categories include:
- Company or product documentation
- Internal policies and procedures
- FAQs and support content
- Research summaries or competitive intelligence
- Training materials or onboarding guides
Don’t try to include everything. The best bundles are focused and purposeful. A bundle for a customer support agent looks very different from one built for a code review agent.
Clean and Structure Your Source Documents
Raw documents often contain noise — formatting artifacts, redundant headers, outdated sections. Before bundling, do a pass to:
- Remove irrelevant or outdated content
- Standardize heading hierarchy (H1 for title, H2 for sections, and so on)
- Add clear labels or metadata where the content isn’t self-evident
- Break very long documents into logical sub-documents
- Replace jargon with plain language where possible, or add a glossary section
Well-structured documents improve retrieval quality significantly. Agents don’t read documents like humans do — they retrieve chunks, and messy structure makes chunking unpredictable.
Define Your Retrieval Intent
Before building, ask: what kinds of questions should this bundle answer? Write down 10–15 representative queries your agent will likely receive. This exercise helps you spot gaps in your content before you package it, and it gives you a benchmark to test against after import.
How to Build an OKF Knowledge Bundle: Step by Step
Step 1: Set Up Your Working Directory
Create a local folder for your bundle project. Inside it, create three subdirectories:
/my-knowledge-bundle
/sources ← raw documents go here
/processed ← cleaned versions go here
/bundle ← output folder for the final OKF package
Keeping processed files separate from source files makes it easy to iterate without losing originals.
Step 2: Prepare and Convert Your Source Files
OKF works best with plain text formats. Convert your documents to one of the following:
.md(Markdown) — preferred for formatted documents.txt— for simple plain text.json— for structured data like FAQs, product specs, or lookup tables.csv— for tabular data
For PDFs, use a tool like Adobe Acrobat or an open-source converter to extract text before converting to Markdown. Don’t copy raw PDF text directly — the formatting is usually garbled.
For web pages, copy the main body text into a Markdown file and save it with a descriptive filename. The filename becomes part of the bundle’s metadata, so be intentional: returns-policy.md is more useful than doc-03.md.
Step 3: Write Your Manifest File
The manifest is a JSON file (manifest.json) that lives at the root of your bundle directory. It describes every document in the bundle and defines key configuration options.
A basic manifest looks like this:
{
"bundle_name": "Acme Support Knowledge Base",
"version": "1.0.0",
"description": "Product documentation and FAQs for customer support agents",
"created": "2025-01-01",
"author": "support-team@acme.com",
"documents": [
{
"id": "returns-policy",
"file": "sources/returns-policy.md",
"title": "Returns and Refunds Policy",
"tags": ["policy", "returns", "customer-service"],
"priority": "high"
},
{
"id": "shipping-faq",
"file": "sources/shipping-faq.md",
"title": "Shipping FAQ",
"tags": ["shipping", "faq", "logistics"],
"priority": "medium"
}
],
"retrieval": {
"chunk_size": 512,
"chunk_overlap": 64,
"embedding_hint": "text-embedding-3-small"
}
}The retrieval block is optional but recommended. Setting chunk size and overlap upfront ensures consistent behavior across different import environments.
Step 4: Validate Your Bundle Structure
Before exporting, run a quick manual check:
- Every file listed in the manifest actually exists in the correct path
- No documents have duplicate IDs
- All source files are in a supported format
- The manifest JSON is valid (paste it into a JSON validator to confirm)
- Document tags are consistent — if you used “customer-service” in one place, don’t switch to “customer_service” in another
If your team uses Git, this is a good point to commit your work.
Step 5: Package the Bundle
Zip your entire bundle directory into a single archive file, then rename the extension from .zip to .okf (or keep it as .zip if the target system doesn’t require the OKF extension — this varies by platform).
zip -r my-knowledge-bundle.okf my-knowledge-bundle/That’s your OKF bundle. It’s now ready to share and import.
How to Import an OKF Bundle into an AI Agent
The import process varies by platform, but the general pattern is the same across most systems.
In a RAG-Based Agent
If you’re working with a retrieval-augmented generation (RAG) setup, import works like this:
- Upload the bundle to your vector database or knowledge management layer
- The system reads the manifest to understand the document structure
- Documents are chunked and embedded according to the manifest’s retrieval settings
- The agent queries the embedded knowledge at inference time
Most modern RAG pipelines (LangChain, LlamaIndex, and similar frameworks) can parse manifest-driven bundles directly. If you’re using a custom setup, write a small import script that reads the manifest and processes each listed document.
In a No-Code Agent Builder
Platforms that support OKF bundles typically provide a direct upload interface. You’ll find a “Knowledge Base” or “Import Knowledge” section in the agent configuration. Upload your .okf file, and the platform handles the rest — chunking, embedding, and indexing.
After import, test with the representative queries you wrote in Step 1. Check that the agent surfaces relevant content and that the retrieved chunks make sense in context.
Sharing Bundles with Other Teams
One of the main advantages of OKF is that the same bundle can be shared like any file. Export it, email it, put it in a shared drive, or commit it to a repository. Anyone who receives the bundle can import it into their own agent setup without needing access to your original documents or configuration.
For teams with multiple agents across departments, a shared bundle library makes it easy to maintain consistent knowledge without central coordination overhead.
Managing and Updating Your Bundle Over Time
Knowledge bundles aren’t static. Policies change, products evolve, new FAQs emerge. Building a maintenance routine into your workflow from the start saves a lot of pain later.
Version Your Bundles
Use semantic versioning in your manifest (1.0.0, 1.1.0, 2.0.0) and keep older versions archived. This matters when you have multiple agents relying on the same bundle — you don’t want a knowledge update to silently break an agent that depended on specific content.
Track Changes to Source Documents
Keep a changelog at the root of your bundle directory:
CHANGELOG.md
- 2025-03-01: Updated returns policy to reflect new 60-day window
- 2025-02-15: Added shipping FAQ for international ordersWhen you re-export the bundle, bump the version number and note the changes.
Set a Review Cadence
Schedule a quarterly review of your knowledge bundles. Look for:
- Documents that reference outdated products, prices, or policies
- Missing content that agents are frequently failing to answer
- Tags or categories that have drifted from the actual content
A clean, current bundle significantly outperforms a larger but stale one.
Where MindStudio Fits Into This Workflow
Building an OKF knowledge bundle solves the packaging problem. But you still need a place to deploy agents that actually use it.
MindStudio is a no-code platform for building and deploying AI agents. Once you’ve built your knowledge bundle, you can import it directly into a MindStudio workflow and wire it to an agent that queries it in real time.
What makes this combination particularly useful is that MindStudio supports over 200 AI models — including Claude, GPT-4o, and Gemini — so you’re not locked into a single model for knowledge retrieval. You can test your bundle against different models and pick the one that retrieves most accurately for your specific content.
For teams managing multiple knowledge bundles, MindStudio’s workflow automation capabilities mean you can build agents that automatically update or re-import bundles on a schedule — pulling fresh documents from Google Drive, reprocessing them, and deploying the updated knowledge without manual steps.
You can also build separate agents for separate teams, each with their own imported knowledge bundle, all running inside a single workspace. The average build takes under an hour, and you don’t need to write code to connect a knowledge base to an agent.
Try MindStudio free at mindstudio.ai.
Common Mistakes to Avoid
Overstuffing the Bundle
More content isn’t better. A 500-document bundle with weak relevance signals will return noisier results than a focused 50-document bundle. Curate aggressively.
Ignoring Chunk Configuration
Default chunk sizes are rarely optimal. If your documents are dense and technical, smaller chunks (256–512 tokens) tend to work better. If they’re narrative-heavy, larger chunks preserve more context. Test a few configurations against your representative queries before committing.
Using Inconsistent Naming
Documents named policy_v3_FINAL_revised.pdf carry that confusion into the bundle. Clean filenames and titles improve metadata quality and make debugging easier when retrieval goes wrong.
Skipping the Test Phase
Always test your bundle after import with real queries before deploying. What looks good in the manifest often behaves unexpectedly in retrieval. Ten minutes of testing can save hours of debugging.
Frequently Asked Questions
What does OKF stand for?
OKF stands for Open Knowledge Format. It’s a specification for packaging AI knowledge bases — documents, metadata, and retrieval configuration — into portable, shareable bundles that can be imported into different AI agents and systems.
Is OKF the same as a vector database?
No. A vector database is infrastructure for storing and querying embeddings at runtime. An OKF bundle is a portable package of source content and configuration. When you import an OKF bundle, the importing system typically generates embeddings and stores them in a vector index — but the bundle itself is just the structured source material.
Can I use an OKF bundle with any AI agent?
Compatibility depends on whether the agent platform supports the format. Most modern RAG-based systems can parse manifest-driven bundles with minimal adaptation. No-code platforms with dedicated knowledge base import features are generally easiest. Custom agent setups may require a small import script to read the manifest and process documents.
How often should I update my knowledge bundle?
At minimum, review bundles quarterly. For rapidly changing content (like pricing, product specs, or policies), a monthly cadence is better. Use versioning so agents can stay on a stable version while you test updates.
What’s the difference between an OKF bundle and just uploading documents?
Uploading individual documents to each agent is manual, inconsistent, and hard to maintain at scale. An OKF bundle packages everything — including retrieval configuration and metadata — so the same knowledge can be imported cleanly into multiple systems with consistent behavior.
How large can an OKF bundle be?
There’s no hard limit defined in the format spec, but practical limits depend on the platform you’re importing into. Most platforms handle bundles up to several hundred megabytes without issues. For very large knowledge bases, consider splitting into multiple topical bundles rather than one monolithic package.
Key Takeaways
- An OKF knowledge bundle packages your AI knowledge base — documents, metadata, and retrieval configuration — into a single portable file.
- Building a good bundle starts with clean, well-structured source documents and a complete manifest file.
- The manifest is the most important component: it defines what’s in the bundle and how it should be processed on import.
- Version and maintain your bundles like code — use changelogs, semantic versioning, and regular reviews.
- MindStudio lets you import knowledge bundles directly into AI agents, with access to 200+ models and no-code workflow automation to keep knowledge current.
Everyone else built a construction worker.
We built the contractor.
One file at a time.
UI, API, database, deploy.
If you’re ready to turn your knowledge base into something any agent can use, start with a focused bundle, test it against real queries, and iterate from there. The infrastructure is simpler than it looks — the hardest part is knowing what knowledge actually belongs inside.
