RAG Runs

RAG Runs provide observability into every Retrieval-Augmented Generation (RAG) operation performed within Karyam.

Whenever documents are ingested into a Vector Database or knowledge is retrieved during AI execution, Karyam records the entire process as a RAG Run.

This allows teams to monitor, troubleshoot, and optimize their knowledge pipelines with complete transparency.

Why RAG Runs Exist

Knowledge processing involves multiple stages that happen behind the scenes.

Examples include:

Document parsing
Artifact generation
Chunking
Embedding generation
Vector storage
Semantic retrieval
Context building

Without visibility, it becomes difficult to understand why knowledge ingestion failed or why an AI system returned unexpected results.

RAG Runs expose every stage of the pipeline.

RAG Run Types

Karyam records two types of RAG Runs.

Ingestion

Created whenever knowledge is added to a Vector Database.

Typical examples include:

File uploads
Folder Listener processing
Embedding Listener execution
Knowledge synchronization

Retrieval

Created whenever an AI system searches a Vector Database to answer a user’s request.

Examples include:

Agent knowledge retrieval
AI Flow retrieval
Semantic search
Context generation

Knowledge Ingestion

During ingestion, Karyam processes documents before they become searchable.

File Upload
      ↓
Artifact Generation
      ↓
Chunking
      ↓
Embedding Model
      ↓
Vector Database

Each stage is captured within a RAG Run.

Knowledge Retrieval

During execution, the platform retrieves relevant knowledge before generating a response.

User Question
      ↓
Embedding
      ↓
Vector Search
      ↓
Relevant Chunks
      ↓
Context Built
      ↓
Model Response

This entire retrieval pipeline is visible through RAG Runs.

What Information is Recorded?

Each RAG Run contains operational information about the knowledge pipeline.

Typical information includes:

Run ID
Run Type
Status
Source File
Embedding Model
Vector Database
Processing Duration
Execution Timeline
Processing Logs

Processing Stages

A typical ingestion run progresses through several stages.

Started
     ↓
Artifacts Generated
     ↓
Chunking
     ↓
Embeddings Created
     ↓
Stored in Vector Database
     ↓
Completed

Similarly, retrieval runs capture:

Search Started
      ↓
Relevant Chunks Retrieved
      ↓
Context Built
      ↓
Retrieval Completed

Event Timeline

RAG Runs record detailed events throughout execution.

Examples include:

Ingestion Events

Ingestion Started
Model Resolution
Artifact Generation
Chunk Creation
Embedding Generation
Vector Storage
Ingestion Completed

Retrieval Events

Retrieval Started
Search Started
Relevant Chunks Retrieved
Chunk Filtering
Context Built
LLM Processing
Retrieval Completed

Debugging Knowledge Pipelines

RAG Runs help identify issues such as:

Unsupported files
Failed artifact generation
Embedding model failures
Vector database connectivity issues
Retrieval failures
Missing knowledge
Performance bottlenecks

Instead of guessing where a failure occurred, teams can inspect each processing stage.

Relationship to Other Concepts

Files
     ↓
Embedding Listener
     ↓
Embedding Model
     ↓
Vector Database
     ↓
RAG Run
     ↓
Agent / AI Flow

RAG Runs provide operational visibility into the knowledge infrastructure that powers AI systems.

RAG Runs vs Runs

Although both capture execution history, they focus on different parts of the platform.

Runs	RAG Runs
AI execution	Knowledge processing
Agent execution	Document ingestion
AI Flow execution	Semantic retrieval
Tool execution	Embedding generation
Workflow logs	Vector storage and search

Together, they provide complete observability across both AI execution and knowledge processing.

The Karyam Philosophy

Knowledge pipelines should be as observable as application pipelines.

RAG Runs make every stage of document ingestion and retrieval transparent, helping teams build reliable, explainable, and production-ready AI systems.