# Advanced Knowledge Graph Query Patterns

## User Intent

"What are advanced patterns for querying my knowledge graph? Show me graph traversal, subgraph extraction, and complex relationship queries."

## Operation

**SDK Methods**: `queryObservables()`, `queryContents()`, `queryGraph()` (if available)\
**GraphQL**: Complex graph queries with filters\
**Entity**: Advanced observable query patterns

## Prerequisites

* Knowledge graph with extracted entities
* Understanding of relationship queries
* Familiarity with graph concepts

***

## Complete Code Example (TypeScript)

```typescript
import { Graphlit } from 'graphlit-client';
import { ObservableTypes, EntityState } from 'graphlit-client/dist/generated/graphql-types';

const graphlit = new Graphlit();

console.log('=== Advanced Graph Query Patterns ===\n');

// Pattern 1: Subgraph Extraction (N-hop neighborhood)
console.log('Pattern 1: Extract 2-Hop Subgraph\n');

async function extractSubgraph(
  entityId: string,
  depth: number = 2
): Promise<{ nodes: any[]; edges: any[] }> {
  const nodes = new Map();
  const edges: any[] = [];
  const visited = new Set<string>();
  
  async function traverse(id: string, currentDepth: number) {
    if (currentDepth > depth || visited.has(id)) return;
    visited.add(id);
    
    const content = await graphlit.queryContents({
      
        observations: [{ observable: { id } }]
      });
    
    content.contents.results.forEach(item => {
      item.observations?.forEach(obs => {
        nodes.set(obs.observable.id, obs.observable);
        if (obs.observable.id !== id) {
          edges.push({ from: id, to: obs.observable.id });
        }
        
        if (currentDepth < depth) {
          traverse(obs.observable.id, currentDepth + 1);
        }
      });
    });
  }
  
  await traverse(entityId, 0);
  
  return {
    nodes: Array.from(nodes.values()),
    edges
  };
}

const subgraph = await extractSubgraph('entity-id-here', 2);
console.log(`Subgraph: ${subgraph.nodes.length} nodes, ${subgraph.edges.length} edges\n`);

// Pattern 2: Centrality Calculation (most connected entities)
console.log('Pattern 2: Entity Centrality\n');

async function calculateCentrality(
  entityType: ObservableTypes
): Promise<Array<{ name: string; degree: number }>> {
  const entities = await graphlit.queryObservables({
    filter: { types: [entityType] }
  });
  
  const centrality: Array<{ name: string; degree: number }> = [];
  
  for (const entity of entities.observables.results.slice(0, 20)) {  // Limit for demo
    const content = await graphlit.queryContents({
      
        observations: [{ observable: { id: entity.observable.id } }]
      });
    
    // Count unique connected entities
    const connected = new Set<string>();
    content.contents.results.forEach(item => {
      item.observations?.forEach(obs => {
        if (obs.observable.id !== entity.observable.id) {
          connected.add(obs.observable.id);
        }
      });
    });
    
    centrality.push({
      name: entity.observable.name,
      degree: connected.size
    });
  }
  
  return centrality.sort((a, b) => b.degree - a.degree);
}

const topEntities = await calculateCentrality(ObservableTypes.Person);
console.log('Most connected people:');
topEntities.slice(0, 5).forEach((e, i) => {
  console.log(`${i + 1}. ${e.name}: ${e.degree} connections`);
});

console.log('\n✓ Advanced graph queries complete!');
```

***

## Key Patterns

### 1. Subgraph Extraction

Extract neighborhood around entity:

* N-hop traversal
* Collect nodes and edges
* Export for visualization

### 2. Path Finding

Find shortest path between entities:

* Breadth-first search
* Limited depth
* Return path as array

### 3. Community Detection

Find clusters of related entities:

* Co-occurrence analysis
* Connected components
* Group by relationships

### 4. Centrality Metrics

Rank entities by importance:

* Degree centrality (connection count)
* Betweenness centrality (bridge entities)
* PageRank-style scoring

### 5. Temporal Patterns

Analyze graph changes over time:

* First/last entity mentions
* Relationship formation timeline
* Entity lifecycle tracking

***

## Common Patterns

**Ego Network**: Extract all entities connected to one entity\
**Star Schema**: Find entities of type B connected to entity A\
**Triangle Closure**: Find mutual connections (A-B, B-C, A-C)\
**Weak Links**: Find rarely co-occurring entities\
**Strong Links**: Find frequently co-occurring entities

***

## Developer Hints

* Cache content queries to avoid repeated API calls
* Limit graph traversal depth (max 3 hops)
* Use pagination for large result sets
* Parallelize independent queries
* Export to graph visualization tools (D3.js, Cytoscape)

***


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/observable-query-graph-patterns.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.