Filter Content by Entities

User Intent

"How do I find all content mentioning a specific person or organization? Show me entity-based content filtering."

Operation

SDK Method: queryContents() with observations filter GraphQL Query: queryContents Use Case: Entity-driven content discovery

Prerequisites

• Content with extracted entities

• Knowledge of entity IDs or names

• Understanding of Observable model

---

Complete Code Example (TypeScript)

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

const graphlit = new Graphlit();

// Example 1: Find all content mentioning a person
async function findContentByPerson(personName: string) {
  // Step 1: Find the person entity
  const people = await graphlit.queryObservables({
    search: personName,
    filter: { types: [ObservableTypes.Person] }
  });
  
  if (people.observables.results.length === 0) {
    console.log(`No entity found for: ${personName}`);
    return;
  }
  
  const person = people.observables.results[0];
  console.log(`Found entity: ${person.observable.name} (${person.observable.id})\n`);
  
  // Step 2: Find all content mentioning this person
  const content = await graphlit.queryContents({
    filter: {
      observations: [{
        type: ObservableTypes.Person,
        observable: { id: person.observable.id }
      }]
    }
  });
  
  console.log(`Content mentioning ${person.observable.name}: ${content.contents.results.length}`);
  
  // Group by type
  const byType = new Map<string, number>();
  content.contents.results.forEach(item => {
    const type = item.type || 'UNKNOWN';
    byType.set(type, (byType.get(type) || 0) + 1);
  });
  
  console.log('\nBy content type:');
  byType.forEach((count, type) => {
    console.log(`  ${type}: ${count}`);
  });
  
  return content.contents.results;
}

// Example 2: Find content mentioning multiple entities (AND logic)
async function findContentWithMultipleEntities(
  personName: string,
  orgName: string
) {
  // Find entities
  const person = await graphlit.queryObservables({
    search: personName,
    filter: { types: [ObservableTypes.Person] }
  });
  
  const org = await graphlit.queryObservables({
    search: orgName,
    filter: { types: [ObservableTypes.Organization] }
  });
  
  if (person.observables.results.length === 0 || org.observables.results.length === 0) {
    console.log('One or both entities not found');
    return;
  }
  
  // Find content mentioning BOTH
  const content = await graphlit.queryContents({
    filter: {
      observations: [
        {
          type: ObservableTypes.Person,
          observable: { id: person.observables.results[0].observable.id }
        },
        {
          type: ObservableTypes.Organization,
          observable: { id: org.observables.results[0].observable.id }
        }
      ]
    }
  });
  
  console.log(`Content mentioning both ${personName} and ${orgName}: ${content.contents.results.length}`);
  
  return content.contents.results;
}

// Run examples
await findContentByPerson("Kirk Marple");
console.log('\n---\n');
await findContentWithMultipleEntities("Kirk Marple", "Graphlit");

---

Key Patterns

Pattern 1: Single Entity Filter

Find all content mentioning one entity:

const content = await graphlit.queryContents({
  filter: {
    observations: [{
      type: ObservableTypes.Person,
      observable: { id: entityId }
    }]
  }
});

Pattern 2: Multiple Entities (AND)

Content mentioning ALL specified entities:

const content = await graphlit.queryContents({
  filter: {
    observations: [
      { observable: { id: entityId1 } },
      { observable: { id: entityId2 } }
    ]
  }
});

Pattern 3: Entity Type Filter

All content with any entity of type:

const content = await graphlit.queryContents({
  filter: {
    observations: [{
      type: ObservableTypes.Organization
      // No specific observable ID = any organization
    }]
  }
});

Pattern 4: Combined Filters

Entity + content type + date:

const content = await graphlit.queryContents({
  filter: {
    types: [ContentTypes.Email],  // Only emails
    observations: [{
      type: ObservableTypes.Person,
      observable: { id: personId }
    }],
    creationDateRange: {
      from: '2024-01-01'
    }
  }
});

---

Use Cases

1. Entity Timeline: Track mentions over time 2. Cross-Source Discovery: Find entity across email, Slack, docs 3. Relationship Mapping: Content connecting two entities 4. Entity-Specific Search: Scope search to entity context 5. Content Audit: What references this person/org?

---

Developer Hints

• Entity filters query graph database (slower than pure content queries)

• Combine with content type filters for speed

• Use entity search first to get IDs

• Multiple entity filters = AND logic (all must match)

• Great for focused discovery

---