Triple-Threat Search Strategy

How GraphRAG Enhances Retrieval

GraphRAG doesn't replace vector or keyword search—it augments them. Docmet uses a hybrid search fusion strategy:

The Three Search Methods

1. Keyword Search (BM25):

• Purpose: Precision matching for specific terms
• Strengths: Exact phrase matching, acronym handling
• Example Query: "Find mentions of 'SOC2 Type II'"
• Technology: BM25 ranking algorithm

2. Vector Search (Semantic Embeddings):

• Purpose: Conceptual similarity matching
• Strengths: Finds semantically related content even with different wording
• Example Query: "compliance certification" matches documents about "regulatory audit approval"
• Technology: Qdrant vector database with HNSW indexing

3. Graph Traversal (Relationship-Based):

• Purpose: Multi-hop reasoning via entity relationships
• Strengths: Answers questions requiring understanding of connections
• Example Query: "How does X affect Y?" requires traversing relationship edges
• Technology: Graphology graph database with community detection

Fusion Strategy:

Search results from all three methods are:

• Retrieved in parallel for speed
• Scored independently using method-specific algorithms
• Reranked using a learned fusion model that weighs each method based on query type
• Deduplicated to remove overlaps
• Returned as unified result set to the Grader Agent

Example: Complex Query Execution

Query: "What projects funded by the Q3 budget have compliance risks?"

Execution:

• Keyword Search: Finds documents containing "Q3 budget" AND "compliance risks"
• Vector Search: Finds semantically similar docs about "financial planning" and "regulatory violations"
• Graph Traversal:
• • Find "Q3 Budget 2025" node
  • Follow FUNDS edges to all projects
  • For each project, check for HAS_RISK edges with type "compliance"
  • Return connected risk entities

Fusion: Combines 12 docs from keyword, 18 from vector, 8 from graph → Rerank → Return top 10 most relevant

Knowledge Graph Ontology

Supported Entity Types

Docmet automatically extracts and recognizes these entity types:

Standard Entities

• Person: Names, roles, titles
• Organization: Companies, departments, teams
• Location: Cities, countries, office addresses
• Date: Timestamps, fiscal periods, deadlines
• Money: Currency amounts, budget figures

Domain-Specific Entities

• Project: Project names, codes, initiatives
• Policy: Policy documents, regulations, standards
• Contract: Agreement names, contract IDs
• Product: Product names, SKUs, services
• Risk: Identified risks, vulnerabilities, threats
• Requirement: Functional/technical requirements
• Asset: IT assets, equipment, facilities

Relationship Types

Relationships connect entities and carry semantic meaning:

• MANAGES:
• • Example - Sarah Chen MANAGES Project Alpha;
  • Use Case - Org chart, responsibility tracking
• FUNDS:
• • Example - Budget 2025 FUNDS Project Alpha;
  • Use Case - Financial impact analysis
• SUPERSEDES:
• • Example - Policy v2.0 SUPERSEDES Policy v1.0;
  • Use Case - Version control, policy evolution
• REFERENCES:
• • Example - Contract A REFERENCES Policy B;
  • Use Case - Dependency analysis
• DEPENDS_ON:
• • Example - System X DEPENDS_ON Service Y;
  • Use Case - Infrastructure risk assessment
• AUTHORED_BY:
• • Example - Report AUTHORED_BY John Doe;
  • Use Case - Provenance tracking
• MENTIONS:
• • Example - Document A MENTIONS Entity B;
  • Use Case - Co-occurrence analysis
• IMPLEMENTS:
• • Example - Code IMPLEMENTS Requirement;
  • Use Case - Traceability
• IDENTIFIES_RISK_IN:
• • Example - Audit IDENTIFIES_RISK_IN Process;
  • Use Case - Compliance tracking
• GOVERNS:
• • Example - Policy GOVERNS Department;
  • Use Case - Regulatory scope

Custom Ontology

Enterprise customers can define custom entity types and relationship types specific to their domain:

• Example: Pharmaceutical Company
• • Custom Entities: Drug, ClinicalTrial, Molecule, Adverse Event
  • Custom Relationships: REACTS_WITH, CONTRAINDICATED_FOR, TESTED_IN
• Example: Law Firm
• • Custom Entities: Precedent, Jurisdiction, Clause Type, Legal Principle
  • Custom Relationships: CITES, OVERRULES, DISTINGUISHES, APPLIES_IN

Technology Stack

Graph Technology Stack

Core Technologies

Graphology

• Pure JavaScript graph library
• Supports directed/undirected graphs
• Efficient traversal algorithms
• Community detection (Louvain)

Qdrant Vector Database

• Stores vector embeddings alongside graph
• HNSW indexing for fast similarity search
• Enables hybrid vector + graph queries

OpenAI GPT-4 for Entity Extraction

• Few-shot learning for domain entities
• Relationship classification
• Coreference resolution

PostgreSQL for Graph Metadata

• Entity properties (name, type, confidence)
• Relationship properties (type, weight, timestamp)
• Versioning and audit trail

Graph Construction Pipeline

// Simplified example of entity extraction

async function extractEntities(documentText: string): Promise<Entity[]> {

const nerResults = await nerModel.extract(documentText);

const llmResults = await openai.complete({

model: "gpt-4",

prompt: `Extract domain-specific entities (Projects, Policies, Risks) from:

${documentText}

Return as JSON array.`

});

return deduplicateAndMerge(nerResults, llmResults);

}

// Simplified relationship extraction

async function extractRelationships(

entities: Entity[],

context: string

): Promise<Relationship[]> {

// Co-occurrence + LLM classification

const pairs = generateEntityPairs(entities);

return await classifyRelationships(pairs, context);

}

// Build graph

function buildGraph(entities: Entity[], relationships: Relationship[]) {

const graph = new Graph();

entities.forEach(e => graph.addNode(e.id, e.properties));

relationships.forEach(r =>

graph.addEdge(r.source, r.target, { type: r.type, weight: r.confidence })

);

return graph;

}

Query Execution

// Multi-hop graph traversal

function traverse(graph: Graph, startNode: string, relationshipType: string, depth: number) {

const visited = new Set();

const results = [];

function dfs(node: string, currentDepth: number) {

if (currentDepth > depth || visited.has(node)) return;

visited.add(node);

results.push(node);

const neighbors = graph.outNeighbors(node).filter(n =>

graph.getEdgeAttribute(node, n, 'type') === relationshipType

);

neighbors.forEach(n => dfs(n, currentDepth + 1));

}

dfs(startNode, 0);

return results;

}