# 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)

***