Skip to content
Karyam

File Uploads

File uploads are the entry point for enterprise knowledge in Karyam.

Unlike traditional AI platforms where documents are manually attached to chatbots, Karyam uses an event-driven ingestion architecture.

When files are uploaded, Karyam can automatically:

  • Parse content
  • Generate chunks
  • Create embeddings
  • Store vectors
  • Track ingestion progress
  • Expose observability through RAG Runs

This allows enterprise knowledge to continuously evolve alongside business operations.


Uploading a file can trigger an entire retrieval pipeline.

File Upload
↓
Embedding Listener Triggered
↓
Document Parsing
↓
Chunk Generation
↓
Embedding Creation
↓
Vector Storage
↓
RAG Run Created

No manual synchronization is required.


Karyam supports multiple content formats.

  • PDF (.pdf)
  • Microsoft Word (.docx)
  • Text (.txt)
  • Markdown (.md)
  • CSV (.csv)
  • JSON (.json)

  • PNG (.png)
  • JPEG (.jpg)
  • WebP (.webp)
  • GIF (.gif)

Image understanding depends on the configured AI model.


  • MP3 (.mp3)
  • WAV (.wav)
  • M4A (.m4a)
  • FLAC (.flac)
  • WebM (.webm)

Audio ingestion requires a configured speech-to-text integration.


Files are organized using folders.

Embedding listeners can monitor specific folders and automatically trigger ingestion when new content appears.

Example:

knowledge-base/
│
├── hr/
│ ├── employee-handbook.pdf
│ ├── leave-policy.pdf
│ └── benefits-guide.pdf
│
├── finance/
│ ├── reimbursement-policy.pdf
│ └── procurement-guidelines.pdf
│
└── it/
├── vpn-policy.pdf
└── access-sop.pdf

This enables teams to isolate retrieval pipelines by business domain.


Embedding listeners monitor folders for new files.

Example configuration:

Setting Value
Listener Type Embedding
Folder Path /knowledge-base/it
Vector Database IT Vector DB
Embedding Model gemini-embedding-2

Whenever a file is uploaded into the configured folder:

knowledge-base/it/
└── vpn-policy.pdf

the listener automatically starts the ingestion process.


Karyam stores metadata alongside embeddings.

Examples include:

  • File path
  • File name
  • Upload timestamp
  • Workspace identifier
  • Chunk position
  • Source references

Metadata improves retrieval quality and traceability.


Additional context can be provided using sidecar description files.

Example:

vpn-policy.pdf
vpn-policy.pdf.txt

Contents:

This document contains VPN access policies,
renewal procedures, and approval requirements.

The description becomes additional context during retrieval.


Large files are automatically divided into smaller chunks before embeddings are generated.

Example:

50-page employee handbook
↓
175 chunks generated
↓
175 embeddings created

Chunking improves retrieval relevance and context quality.


A user uploads:

vpn-policy.pdf

Karyam executes:

Upload Received
↓
File Parsed
↓
32 Chunks Created
↓
32 Embeddings Generated
↓
Stored In Vector Database
↓
RAG Run Created

The file is now available to agents and workflows.


Navigate to:

RAG Runs

You can monitor:

  • Parsing status
  • Chunk generation
  • Embedding progress
  • Vector storage
  • Failures and retries

This provides complete visibility into ingestion pipelines.


Example:

/hr
/finance
/legal
/engineering
/operations

Good:

vpn-access-policy-2026.pdf
employee-handbook-v3.pdf

Avoid:

document1.pdf
policy-final-final.pdf

Sidecar descriptions improve retrieval quality for:

  • Images
  • Logos
  • Scanned documents
  • Ambiguous content

Always monitor ingestion status after large uploads.

This helps detect:

  • Parsing failures
  • Embedding errors
  • Storage issues

New Policy Uploaded
↓
Embedding Listener Triggered
↓
Embeddings Generated
↓
Vector Database Updated
↓
Agents Immediately Gain Access

No redeployment.

No retraining.

No manual synchronization.


Files
↓
Listeners
↓
Chunking
↓
Embeddings
↓
Vector Database
↓
Retrieval
↓
Agents

File uploads are not just storage.

They are the beginning of an AI system’s understanding of your organization.


Continue with:

➡️ Chunking

Learn how Karyam breaks large documents into retrieval-friendly pieces before generating embeddings.