Agentic knowledge
with precise context
UGENT processes documents, codebases, files, and enterprise knowledge into an indexed, graph-aware context layer. Agents retrieve only the evidence they need, reason over relationships, cite the exact source, and act through scoped tools — with multi-tenant isolation, per-user access control, and durable memory built in.
Two-Plane Architecture
The ingestion plane keeps indexes fresh. The retrieval plane serves low-latency, read-only context to agents and MCP-compatible AI hosts.
From raw files to cited answers
UGENT separates knowledge processing from model reasoning — so the LLM gets only what it needs, with full traceability.
Intake & Filtering
Accept source repositories, Markdown, config files, tables, and converted
enterprise documents. Filter out binaries, archives, and unsafe paths.
Respect repository ignore rules and .ugentignore.
Structure-Aware Chunking
Source code uses AST-aware chunking so functions, classes, and symbols stay intact. Markdown uses heading-aware chunks. Tables carry headers into every chunk. No arbitrary character-window splits.
Hybrid Indexing
Dense vector search for semantic similarity. Lexical BM25 for exact identifiers, error messages, and domain terms. Knowledge graph for dependencies, imports, calls, and architecture. All channels fused into one ranked result set.
Knowledge Graph
Extracts deterministic relationships without sending source code to an LLM: file-contains-symbol, imports, function calls, type implementations. Semantic edges are cached by file hash and retried through a durable backlog.
Pre-LLM Context Bundle
Before calling the LLM, UGENT classifies the request and fetches a compact context bundle: relevant snippets, file paths, line ranges, symbols, citation markers, and token-count estimates — all under a strict budget.
Agentic Retrieval Loop
Search, inspect graph neighbors, read exact line ranges, use LSP tools for definitions and diagnostics, delegate to scoped sub-agents, then synthesize the final answer — only after collecting enough evidence.
Fast and slow ingestion queues
The fast path makes files searchable immediately. The slow path enriches the graph asynchronously — without blocking availability.
Hybrid retrieval with agentic loop
Vector search, lexical matching, and graph traversal run in parallel. Results are fused, reranked, and packed into a token-budgeted context bundle before the LLM reasons. If more detail is needed, agentic tools drill deeper.
Why UGENT is more accurate
Multiple retrieval signals, deterministic citations, role-scoped agents, and security gates — layered controls that keep answers grounded in evidence.
Hybrid Retrieval
Semantic similarity + exact keyword matching + graph relationships. No single retrieval mode can miss what another catches.
Deterministic Citations
Every answer carries file paths, line ranges, and symbol references. A citation verification endpoint can detect fabricated references.
Knowledge Graph Tools
workspace_search, graph_search, and graph_neighbors expose dependency chains, call hierarchies, and architectural neighborhoods that chunk retrieval cannot see.
Security & Governance
Multi-tenant isolation, per-user access control, rate limits, duplicate-call detection, trusted authorization gates, and audit-safe idempotent ingestion.
Why UGENT uses fewer tokens
Context is selected before the LLM call. The model receives a compact bundle instead of a full repository or document history.
Meaningful Chunks
AST, heading, and row-aware chunks keep relevant units intact. Not too little, not too much.
Graph, Not Files
Graph tools return relationships and node IDs, not entire files. The agent reads only when necessary.
Distilled LSP Output
Language-server information is returned as compact pointers and summaries, not raw verbose protocol payloads.
Cacheable Prompts
Stable system prompt content stays separate from per-turn values, improving prompt-cache reuse across turns.
Scoped Sub-Agents
Delegated workers receive only the tools and context needed for their role. A researcher does not inherit broad write tools.
Budget-Gated Output
Tool output is budget-gated. Large results are summarized before persistence and compressed in the current turn when needed.
Context intelligence via MCP
Code search, knowledge graph traversal, natural-language data queries, and durable memory tools — available to UGENT itself and any MCP-compatible AI host. Auto-detects workspace identity and injects codebase identifiers so the LLM does not need to manage them.
workspace_search
Hybrid code and document search with snippet, structure, and synthesis modes.
workspace_overview
Discover all indexed codebases, view graph statistics, and get per-codebase node and edge counts for any codebase.
graph_search
Find code entities by name. Returns graph node IDs for chaining into graph_neighbors.
graph_neighbors
Explore callers, callees, imports, containers, and references around any node.
database_query
Ask data questions in plain English. Generates safe, read-only SQL grounded on auto-profiled table statistics — no pre-embedding required.
memory_recall
Retrieve durable facts and preferences with hybrid lexical plus vector recall, filtered by importance, recency, and tier.
memory_store
Create or update a self-contained fact, preference, or event summary — with optional supersession links and expiry.
memory_forget
Delete records by id or filter. Filters combine with AND and an empty selector is rejected — no accidental mass deletion.
memory_ingest
Queue conversation transcripts for async memory creation with optional LLM fact extraction.
memory_ingest_status
Poll an ingest job for progress, the records it created, and the reason it failed if it did.
Full tool reference, scopes, and client setup in the tenant guide.
Beyond Code: Salesforce, Databases, and More
The same engine that indexes your codebase also understands Salesforce metadata and data, and relational databases. Code, CRM schema, and row-level records all become searchable through one unified knowledge graph.
Salesforce Intelligence
Index your Salesforce DX project — objects, fields, flows, permissions, layouts, Agentforce bots — then go beyond metadata and index synced records. Your own data cloud, local-first.
Explore Salesforce integrationRelational Databases
Connect PostgreSQL or MySQL and ask data questions in plain English. The engine auto-profiles every table, generates safe read-only SQL grounded on real column statistics, and learns from confirmed queries so the same question runs instantly next time — no row pre-embedding, no per-row cost.
Advanced Retrieval
Query expansion, cross-encoder reranking, daemon mode, durable semantic backlog recovery, and a self-service tenant console for managing codebases, secrets, keys, and memory. Every layer is optional and disabled by default.
Bring your SaaS data, securely
Tenants authorize their own CRM, helpdesk, or SaaS account through OAuth and the engine indexes the records into their workspace. No operator handles a credential. No data is written back to the provider. Read-only, always.
Tenant Self-Service OAuth
Each tenant authorizes their own account through a browser-based OAuth flow with PKCE. The consent is single-use and bound to one tenant and one connection. The tenant can revoke access anytime from the provider's own settings.
Read-Only By Design
Connections pull records, never source code. Scopes are compile-time constants verified at build and runtime — no descriptor can request source access, and no response ever contains a token.
Access-Rule Aware
Records land in a dedicated workspace per connection and object type. They carry no access labels until the tenant writes a rule — so a new connection stays private until the tenant explicitly shares it with their team.
Per-Connection Visibility
Existing access rules work seamlessly: a rule for
crm/deals/* restricts one object type of one
connection with no new code. Each connection type gets its own
path namespace.
Setup Diagnostics
Five connection health checks surface silent problems: no access rule, scope not granted, token expired, never synced, and last sync failed. Each reports something legal but invisible to a tenant who cannot read server logs.
Sync Status Tracking
Each connection reports last sync start, finish, and record count. A sync in flight is distinguishable from one that never ran, and zero records is a real outcome reported separately from a failure.
One engine, every tenant isolated
Serve multiple teams or customers from a single deployment. Each tenant gets its own encrypted credentials, isolated codebases, and independent model configuration — with fail-closed enforcement on every request.
Encrypted Tenant Secrets
Each tenant's API keys and database connections are sealed with strong encryption. Secrets are referenced, never exposed in config reads, and rotated without downtime.
Per-Tenant Configuration
Each tenant can bring their own embedding, reranker, and database providers — or inherit the platform defaults. Hot-reload swaps configuration atomically while in-flight jobs drain safely.
Generation-Safe Reload
Configuration changes are preflighted and published atomically. The previous generation drains its in-flight work, while new requests immediately use the updated settings — no downtime, no data loss.
Outbound URL Validation
Tenant-supplied endpoints are validated against scheme, address, DNS, and redirect policy before any connection is made. Loopback, private, and metadata addresses are blocked by default.
Flexible Vector Isolation
Choose shared collections with per-tenant filters for efficiency, or dedicated collections and instances for stronger operational isolation. Migrate between modes with atomic verification.
Usage Metering & Quotas
Track token consumption per tenant with atomic reserve/commit flows that prevent overshoot near the limit. Set billing-cycle quotas, view per-model cost estimates, and enforce with shadow or hard-stop modes.
Per-user visibility, fail-closed
Share one indexed workspace across many users — each sees only what they are entitled to. Access labels are stamped at ingest time and enforced across every retrieval path, including the knowledge graph.
Path-Based Visibility
Documents are tagged with access labels derived from their file path. Users in a group see shared folders; individuals see their own work. Admins bypass filtering entirely.
Server-Side Enforcement
Access conditions are added on top of — never replacing — tenant isolation. The acting user is resolved server-side, never trusted from tool arguments, and unknown or disabled users are rejected on the spot.
Graph-Aware Filtering
Every search path is protected: vector results, lexical matches, graph traversal, and memory recall all respect per-user visibility. Invisible graph nodes are dropped before response.
Key-Level User Binding
Pin an API key to a specific user for zero-config access. The key always acts as that user, cannot impersonate anyone else, and requires no additional configuration from clients.
Setup Diagnostics
Three read-only endpoints explain what access control is doing without impersonating a user: explain a user's resolved labels, run health checks with stable codes, and list the scope registry. Everything is computed from configuration — no indexed document is read, so it is fast and cannot leak content.
Setting this up for a team? See adding team members and writing access rules.
Memory that persists across sessions
A tenant-scoped memory store for external applications — facts, preferences, and past-event summaries that survive across sessions. Accessed over HTTP or MCP, with hybrid recall combining lexical matching with vector similarity.
Three Memory Types
Semantic facts, episodic event summaries, and procedural instructions — each with tiered retrieval priority so the most important memories surface first.
Hybrid Recall
Full-text search fuses with optional vector similarity through reciprocal rank fusion, weighted by importance and recency. Layered recall supports multi-scope visibility widening.
Smart Ingest
Queue conversation transcripts for async memory creation. Smart mode extracts durable facts through an LLM and stores each individually, with a fallback to raw transcript storage.
Governance Tools
Browse, filter, correct, import, and export what your applications remember. A recall tester and transcript ingest tool are built into the tenant console.
Privacy by Design
Memory is pinned to the acting user — a non-admin user only sees their own records plus shared ones. Superseded and expired records are hidden from default recall automatically.
Dual Backend
SQLite for development and low-volume deployments, PostgreSQL for production — selected by configuration, with the same isolation and recall behavior across both.
Your data never leaves your control
For enterprise deployments, UGENT runs entirely on your own infrastructure. No data is viewed, stored, or analyzed by UGENT. For individual users, a managed SaaS platform is available so you can get started without hosting anything yourself. In both cases, the only outbound traffic is to the language model and embedding providers you explicitly configure.
Self-Hosted or SaaS
Enterprise on-prem, individual managed
Your Keys
Encrypted, never shared
No Telemetry
Zero data collection
Bring your workspace into UGENT
Ask complex questions, get grounded answers, and let scoped agents act with the right context instead of an overloaded prompt.