Skip to main content
Knowledge bases are collections of documents that agents can search semantically. Combined with LLM reasoning, this creates RAG (Retrieval-Augmented Generation): AI responses grounded in your actual data.

​
Problem Solved

​
Without Knowledge Base

User: "What's our return policy?"
Agent: "Returns are typically 30 days, but I'm not sure
        about our specific policy. You should check the
        website or contact support."
        (Hallucination risk!)

​
With Knowledge Base

User: "What's our return policy?"
Agent: [Searches knowledge base]
       "According to our policy document, returns are
        accepted within 60 days if items are unused.
        Full refunds include original shipping cost."
       (Accurate, sourced, confident)

​
How Knowledge Bases Work

​
Creating a Knowledge Base

Step 1: Create Knowledge Base 
Console → Knowledge Bases → Create
Name: "Product Documentation"
Description: "Documentation for our SaaS product"
Step 2: Upload Documents Supported formats:
  • PDF
  • Word (DOCX)
  • Plain text
  • Markdown
  • Web pages (URL)
Console → Knowledge Base → Upload Documents
Files: product_guide.pdf, faq.md, help_articles.zip
Step 3: Chunking Documents are split into chunks for better indexing: Configurable chunking: 
{
  "chunk_size": 1024,         // words per chunk
  "chunk_overlap": 128,       // overlap for context
  "separator": "\n\n"         // split on paragraphs
}
Step 4: Embedding Each chunk is converted to a vector: 
Chunk: "Returns accepted within 60 days of purchase,
        as long as items are unused and in original
        packaging. Refunds include original shipping."

Vector: [0.123, 0.456, 0.789, ..., 0.234]
        (1,536 dimensions for OpenAI embeddings)
Step 5: Indexing Vectors stored in the vector database for fast search: When an agent needs information, it searches: Why semantic search > keyword search:
QueryKeyword MatchSemantic Match
”Can I get my money back?”✗ (no “refund”)✓ Finds refund policy
”returning a product”✗ (no “return”)✓ Finds return policy
”how long to send back”~ (partial)✓ Finds time window
Semantic search understands meaning, not just keywords.

​
LLM Reranking

For better accuracy, search results can be reranked by an LLM: 
Initial Results (from vector search):
  1. Returns policy (similarity: 0.95)
  2. FAQ section (similarity: 0.72)
  3. Warranty doc (similarity: 0.68)

LLM Reranking:
  "Given query 'return after 2 months', which
   document is MOST relevant?"

  Reranked Results:
  1. Returns policy (rerank score: 0.99) ← most relevant
  2. Warranty doc (rerank score: 0.45)
  3. FAQ section (rerank score: 0.12)
Benefits:
  • Catches documents vector search misses
  • Better for complex queries
  • Trade-off: slower (LLM inference)
Configuration: 
{
  "knowledge_base_config": {
    "reranker_enabled": true,      // enable reranking
    "max_results": 5               // top 5 per search
  }
}

​
RAG in Action

Full RAG workflow:

​
Configurating Knowledge Bases

Per-knowledge-base settings: 
{
  "config": {
    "reranker_enabled": null,    // null = use global setting
                                 // true = force ON
                                 // false = force OFF
    "max_results": 10            // max documents per search
  }
}
Global reranker config (affects all KBs): 
Settings → Knowledge → Reranker
├─ Enabled: true
├─ Model: "gpt-5-nano"
└─ Timeout: 5 seconds

​
Knowledge Base Management

​
Adding More Documents

Console → Knowledge Base → Add Documents
├─ Upload new files
├─ Or import from URL
└─ Docs automatically chunked and embedded

​
Updating Documents

Console → Knowledge Base → Documents → Edit
├─ Update content
├─ Change chunking settings
├─ Re-embed and index

​
Removing Documents

Console → Knowledge Base → Documents → Delete
├─ Remove source
├─ Chunks automatically deleted from index
└─ Storage freed

​
Exporting Data

Console → Knowledge Base → Export
├─ Download as JSON (chunks + metadata)
├─ Download original docs
├─ Full search history (optional)

​
Embeddings

Noorle uses OpenAI embeddings by default: 
Model: text-embedding-3-small
Dimensions: 1,536
Max input: 8,191 tokens
For current pricing details, see Pricing. Custom embeddings (enterprise):
  • Bring your own embedding model
  • Use open-source embeddings (Hugging Face)
  • Custom training on domain-specific data
Search across multiple knowledge bases: Use cases:
  • Multi-product documentation
  • Organizational wikis (separated by dept)
  • Versioned documentation

​
Two Ways Agents Use Knowledge

There are two distinct paths for giving agents access to knowledge:

​
Path 1: Automatic Context Injection (RAG)

Attach a knowledge base directly to an agent. When the agent runs, relevant documents are automatically retrieved and injected into the prompt context before the LLM generates a response. When to use: The agent always needs access to specific documentation. Every conversation benefits from having this knowledge available. Good for support agents, FAQ bots, and domain-specific assistants. How to set up: Configure knowledge_base_ids on the agent. The platform handles retrieval automatically at the start of each execution.

​
Path 2: Knowledge as a Tool

Attach the Knowledge Retrieval built-in capability to the agent. The agent gets search, get_by_id, and list tools that it can call on demand during a conversation. When to use: The agent only sometimes needs knowledge lookups. The agent should decide when and what to search. Good for general-purpose agents that handle a mix of tasks. How to set up: Attach the Knowledge Retrieval capability in the agent’s settings. The agent decides when to invoke searches based on the conversation.

​
Combining Both Paths

You can use both paths together. The agent gets automatic context from attached knowledge bases and can also explicitly search additional knowledge bases via the tool. This is useful when there’s “always needed” knowledge (Path 1) plus “sometimes needed” reference material (Path 2).

​
Best Practices

Chunk Intelligently

Chunk on semantic boundaries (paragraphs, sections). Overlap prevents loss of context.

Metadata Matters

Tag chunks with source, date, category. Helps filter and debug results.

Monitor Quality

Review search results regularly. Tune chunking and reranking based on quality.

Update Documents

Keep docs current. Old or incorrect docs harm RAG quality.

​
Common Patterns

​
Pattern: Customer Support Agent

Knowledge Base: FAQ, policies, troubleshooting guides

Agent search flow:
  1. User: "My account is locked"
  2. Agent searches: "account locked"
  3. Find troubleshooting guide
  4. Return step-by-step fix

​
Pattern: Internal Knowledge Hub

Knowledge Bases:
  1. Company policies
  2. Engineering runbooks
  3. Sales playbooks

Agent: "Help me follow the incident response playbook"
  └─ Searches KB, finds procedure, guides human through steps

​
Pattern: Multi-Source Documentation

Knowledge Bases:
  1. API docs
  2. Architecture guide
  3. Deployment procedures

Agent: "How do I deploy this API?"
  └─ Searches all KBs, synthesizes answer from multiple sources

​
Troubleshooting

ProblemSolution
Poor search resultsCheck chunks aren’t too large/small. Adjust to 512-1024 words.
Irrelevant matchesEnable LLM reranking to filter false positives.
Missing documentsRe-upload and re-embed. Check for content duplicates.
Slow searchesIncrease max_results limit. Add indexes.
High costsDisable reranking for non-critical searches. Batch embeddings.
Next: Discover Omni Tool for intelligent tool discovery.