> For the complete documentation index, see [llms.txt](https://docs.graphlit.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/content-entity-co-occurrence.md).

# Analyze Entity Co-Occurrence

## User Intent

"How do I find content where multiple entities appear together? Show me entity co-occurrence patterns."

## Operation

**SDK Methods**: `queryContents()` with multiple entity filters\
**GraphQL**: Multi-entity content queries\
**Use Case**: Relationship discovery through co-occurrence

## Prerequisites

* Content with extracted entities
* Multiple entities to analyze
* Understanding of entity relationships

***

## Complete Code Example (TypeScript)

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

const graphlit = new Graphlit();

// Find entities
const kirk = await graphlit.queryObservables({
  search: "Kirk Marple",
  filter: { types: [ObservableTypes.Person] }
});

const maria = await graphlit.queryObservables({
  search: "Maria Garcia",
  filter: { types: [ObservableTypes.Person] }
});

// Find co-occurrence
const cooccurrence = await graphlit.queryContents({
  
    observations: [
      { observable: { id: kirk.observables.results[0].observable.id } },
      { observable: { id: maria.observables.results[0].observable.id } }
    ]
  });

console.log(`Kirk and Maria mentioned together in ${cooccurrence.contents.results.length} documents`);

// Build co-occurrence matrix
const people = await graphlit.queryObservables({
  filter: { types: [ObservableTypes.Person] }
});

const matrix = new Map<string, Map<string, number>>();

for (let i = 0; i < people.observables.results.length; i++) {
  for (let j = i + 1; j < people.observables.results.length; j++) {
    const personA = people.observables.results[i];
    const personB = people.observables.results[j];
    
    const together = await graphlit.queryContents({
      
        observations: [
          { observable: { id: personA.observable.id } },
          { observable: { id: personB.observable.id } }
        ]
      });
    
    const count = together.contents.results.length;
    if (count > 0) {
      if (!matrix.has(personA.observable.name)) {
        matrix.set(personA.observable.name, new Map());
      }
      matrix.get(personA.observable.name)!.set(personB.observable.name, count);
    }
  }
}

// Display top co-occurrences
console.log('\nTop co-occurrences:');
const flat: Array<{ a: string; b: string; count: number }> = [];
matrix.forEach((bMap, a) => {
  bMap.forEach((count, b) => {
    flat.push({ a, b, count });
  });
});

flat.sort((x, y) => y.count - x.count)
  .slice(0, 10)
  .forEach(({ a, b, count }) => {
    console.log(`  ${a} ↔ ${b}: ${count} times`);
  });
```

***

## Key Patterns

### 1. Pairwise Co-occurrence

Two specific entities:

```typescript
observations: [
  { observable: { id: entityA } },
  { observable: { id: entityB } }
]
```

### 2. Entity + Type

Specific entity with any of type:

```typescript
observations: [
  { observable: { id: personId } },
  { type: ObservableTypes.Organization }
]
```

### 3. Co-occurrence Strength

Frequency indicates relationship strength

***

## Use Cases

**Team Collaboration Analysis**: Who works with whom\
**Influence Mapping**: Entity co-mention networks\
**Topic Association**: Products + Organizations\
**Relationship Discovery**: Find hidden connections

***

## Developer Hints

* Co-occurrence implies relationship
* Frequency = strength
* Useful for network analysis
* Export for graph visualization
* Can be computationally expensive (cache results)

***