> 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/observable-entity-types-comprehensive.md).

# Comprehensive Entity Types Reference

## Observable: Comprehensive Entity Types Reference

### User Intent

"What entity types can Graphlit extract? What properties does each type have?"

### Operation

* **Concept**: Observable entity types (Schema.org-based)
* **GraphQL Enum**: ObservableTypes
* **Entity Types**: 20+ types supported
* **Common Use Cases**: Understanding available entities, choosing extraction types, entity properties

### All Observable Types

Graphlit supports 20+ entity types, all based on Schema.org standards for interoperability.

### Core Entity Types

#### Person

**Type**: `ObservableTypes.Person`\
**Schema.org**: `@type: "Person"`\
**Use For**: People, authors, contacts, team members, contributors

**Properties**:

```typescript
{
  name: string;                    // Full name
  email: string;                   // Email address
  givenName: string;               // First name
  familyName: string;              // Last name
  jobTitle: string;                // Job title/role
  affiliation: string;             // Company/organization
  telephone: string;               // Phone number
  address: string;                 // Physical address
}
```

**Examples**:

* "Kirk Marple, CEO of Graphlit"
* "Maria Garcia, Software Engineer at Microsoft"
* Contact information in emails

#### Organization

**Type**: `ObservableTypes.Organization`\
**Schema.org**: `@type: "Organization"`\
**Use For**: Companies, teams, departments, organizations

**Properties**:

```typescript
{
  name: string;                    // Organization name
  description: string;             // Description
  url: string;                     // Website URL
  foundingDate: string;            // When founded
  location: string;                // Headquarters location
}
```

**Examples**:

* "Graphlit, a context layer for AI agents"
* "Microsoft Corporation"
* "Stanford University"

#### Place

**Type**: `ObservableTypes.Place`\
**Schema.org**: `@type: "Place"`\
**Use For**: Locations, offices, venues, geographic entities

**Properties**:

```typescript
{
  name: string;                    // Place name
  address: {
    streetAddress: string;
    city: string;
    region: string;                // State/province
    country: string;
    postalCode: string;
  };
  geo: {
    latitude: number;
    longitude: number;
  };
  h3: string;                      // H3 geospatial index
}
```

**Examples**:

* "Seattle, Washington"
* "123 Main St, San Francisco, CA 94105"
* "Golden Gate Park"

#### Event

**Type**: `ObservableTypes.Event`\
**Schema.org**: `@type: "Event"`\
**Use For**: Meetings, conferences, appointments, events

**Properties**:

```typescript
{
  name: string;                    // Event name
  description: string;             // Event description
  startDate: string;               // Start date/time
  endDate: string;                 // End date/time
  location: string;                // Where it takes place
  attendees: string[];             // Who attends
  organizer: string;               // Who organizes
}
```

**Examples**:

* "AWS re:Invent 2024"
* "Q4 Planning Meeting"
* "Product Launch Event"

#### Product

**Type**: `ObservableTypes.Product`\
**Schema.org**: `@type: "Product"`\
**Use For**: Products, tools, services

**Properties**:

```typescript
{
  name: string;                    // Product name
  brand: string;                   // Brand/manufacturer
  price: number;                   // Price
  description: string;             // Product description
  manufacturer: string;            // Who makes it
}
```

**Examples**:

* "iPhone 15 Pro"
* "Tesla Model 3"
* "Adobe Photoshop"

#### Repo

**Type**: `ObservableTypes.Repo`\
**Schema.org**: `@type: "SoftwareSourceCode"`\
**Use For**: GitHub/GitLab repositories, source code repos

**Properties**:

```typescript
{
  name: string;                    // Repository name
  url: string;                     // Repository URL
  owner: string;                   // Owner/organization
  description: string;             // Repository description
}
```

**Examples**:

* "graphlit/graphlit-samples"
* "facebook/react"
* "microsoft/vscode"

#### Software

**Type**: `ObservableTypes.Software`\
**Schema.org**: `@type: "SoftwareApplication"`\
**Use For**: Software products, applications, tools

**Properties**:

```typescript
{
  name: string;                    // Software name
  version: string;                 // Version number
  description: string;             // What it does
  manufacturer: string;            // Who makes it
}
```

**Examples**:

* "Python 3.11"
* "Docker"
* "PostgreSQL 15"

### Classification Types

#### Category

**Type**: `ObservableTypes.Category`\
**Schema.org**: `@type: "Thing"` with category\
**Use For**: Topics, classifications, tags, subjects

**Properties**:

```typescript
{
  name: string;                    // Category name
  description: string;             // Category description
}
```

**Examples**:

* "Machine Learning"
* "Product Development"
* "Financial Reports"

#### Label

**Type**: `ObservableLabel`\
**Schema.org**: `@type: "Thing"` with label\
**Use For**: Tags, labels, keywords

**Properties**:

```typescript
{
  name: string;                    // Label name
  color: string;                   // Label color (optional)
  description: string;             // Label description
}
```

**Examples**:

* "urgent"
* "bug"
* "high-priority"

### Medical Entity Types (12 types)

**All fully supported** - not beta

#### MedicalCondition

**Type**: `ObservableTypes.MedicalCondition`\
**Schema.org**: `@type: "MedicalCondition"`\
**Use For**: Diseases, symptoms, diagnoses

**Examples**:

* "Type 2 Diabetes"
* "Hypertension"
* "COVID-19"

#### MedicalDrug

**Type**: `ObservableTypes.MedicalDrug`\
**Schema.org**: `@type: "Drug"`\
**Use For**: Medications, pharmaceuticals

**Examples**:

* "Aspirin"
* "Metformin"
* "Lisinopril"

#### MedicalDrugClass

**Type**: `ObservableMedicalDrugClass`\
**Schema.org**: `@type: "DrugClass"`\
**Use For**: Drug categories

**Examples**:

* "Antibiotics"
* "Beta blockers"
* "Statins"

#### MedicalProcedure

**Type**: `ObservableTypes.MedicalProcedure`\
**Schema.org**: `@type: "MedicalProcedure"`\
**Use For**: Surgeries, medical procedures

**Examples**:

* "Appendectomy"
* "MRI Scan"
* "Blood Transfusion"

#### MedicalTest

**Type**: `ObservableTypes.MedicalTest`\
**Schema.org**: `@type: "MedicalTest"`\
**Use For**: Diagnostic tests, lab tests

**Examples**:

* "Complete Blood Count"
* "X-Ray"
* "Glucose Tolerance Test"

#### MedicalStudy

**Type**: `ObservableTypes.MedicalStudy`\
**Schema.org**: `@type: "MedicalStudy"`\
**Use For**: Clinical trials, research studies

**Examples**:

* "Phase III Clinical Trial"
* "Longitudinal Study on Heart Disease"

#### MedicalDevice

**Type**: `ObservableMedicalDevice`\
**Schema.org**: `@type: "MedicalDevice"`\
**Use For**: Medical equipment, devices

**Examples**:

* "Pacemaker"
* "Insulin Pump"
* "Stethoscope"

#### MedicalTherapy

**Type**: `ObservableMedicalTherapy`\
**Schema.org**: `@type: "MedicalTherapy"`\
**Use For**: Treatments, therapies

**Examples**:

* "Physical Therapy"
* "Radiation Therapy"
* "Cognitive Behavioral Therapy"

#### MedicalGuideline

**Type**: `ObservableMedicalGuideline`\
**Schema.org**: `@type: "MedicalGuideline"`\
**Use For**: Clinical guidelines, protocols

**Examples**:

* "AHA Heart Disease Guidelines"
* "CDC Vaccination Schedule"

#### MedicalIndication

**Type**: `ObservableMedicalIndication`\
**Schema.org**: `@type: "MedicalIndication"`\
**Use For**: Reasons for treatment

**Examples**:

* "High Blood Pressure"
* "Bacterial Infection"

#### MedicalContraindication

**Type**: `ObservableMedicalContraindication`\
**Schema.org**: `@type: "MedicalContraindication"`\
**Use For**: Reasons to avoid treatment

**Examples**:

* "Pregnancy"
* "Allergy to Penicillin"

### TypeScript (Canonical)

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

const graphlit = new Graphlit();

// Extract all core types
const workflow = await graphlit.createWorkflow({
  name: "Comprehensive Extraction",
  preparation: {
    jobs: [{
      connector: {
        type: FilePreparationServiceTypes.Document
      }
    }]
  },
  extraction: {
    jobs: [{
      connector: {
        type: EntityExtractionServiceTypes.ModelText,
        extractedTypes: [
          // Core types
          ObservableTypes.Person,
          ObservableTypes.Organization,
          ObservableTypes.Place,
          ObservableTypes.Event,
          ObservableTypes.Product,
          ObservableTypes.Repo,
          ObservableTypes.Software,
          // Classification
          ObservableTypes.Category,
          ObservableTypes.Label
        ]
      }
    }]
  }
});

// Extract medical types
const medicalWorkflow = await graphlit.createWorkflow({
  name: "Medical Extraction",
  extraction: {
    jobs: [{
      connector: {
        type: EntityExtractionServiceTypes.ModelText,
        extractedTypes: [
          ObservableTypes.MedicalCondition,
          ObservableTypes.MedicalDrug,
          ObservableTypes.MedicalProcedure,
          ObservableTypes.MedicalTest,
          ObservableTypes.MedicalStudy
        ]
      }
    }]
  }
});
```

### Use Cases by Domain

#### Business Documents

```typescript
extractedTypes: [
  ObservableTypes.Person,           // Employees, contacts
  ObservableTypes.Organization,     // Companies, partners
  ObservableTypes.Place,            // Offices, locations
  ObservableTypes.Event,            // Meetings, conferences
  ObservableTypes.Product           // Products discussed
]
```

#### Legal Documents

```typescript
extractedTypes: [
  ObservableTypes.Person,           // Parties, attorneys
  ObservableTypes.Organization,     // Companies involved
  ObservableTypes.Place,            // Jurisdiction, addresses
  ObservableTypes.Event             // Important dates
]
```

#### Technical Documentation

```typescript
extractedTypes: [
  ObservableTypes.Software,         // Technologies mentioned
  ObservableTypes.Product,          // Products/tools
  ObservableTypes.Repo,             // Code repositories
  ObservableTypes.Organization      // Companies/projects
]
```

#### Medical Literature

```typescript
extractedTypes: [
  ObservableTypes.MedicalCondition,
  ObservableTypes.MedicalDrug,
  ObservableTypes.MedicalProcedure,
  ObservableTypes.MedicalTest,
  ObservableTypes.MedicalStudy,
  ObservableTypes.Person,           // Researchers, authors
  ObservableTypes.Organization      // Research institutions
]
```

#### News Articles

```typescript
extractedTypes: [
  ObservableTypes.Person,           // People mentioned
  ObservableTypes.Organization,     // Companies, orgs
  ObservableTypes.Place,            // Locations
  ObservableTypes.Event,            // News events
  ObservableTypes.Category          // Topics, subjects
]
```

#### GitHub/Code

```typescript
extractedTypes: [
  ObservableTypes.Repo,             // Repositories
  ObservableTypes.Person,           // Contributors
  ObservableTypes.Organization,     // Companies, teams
  ObservableTypes.Software,         // Technologies
  ObservableTypes.Label             // Issue labels
]
```

## All entity types available as enums

extraction\_types = \[ ObservableTypes.PERSON, ObservableTypes.ORGANIZATION, ObservableTypes.PLACE, ObservableTypes.EVENT, ObservableTypes.PRODUCT, ObservableTypes.REPO, ObservableTypes.SOFTWARE, ObservableTypes.CATEGORY, ObservableTypes.LABEL, # Medical types ObservableTypes.MEDICAL\_CONDITION, ObservableTypes.MEDICAL\_DRUG, # ... etc ]

````

**C#**:
```csharp
using Graphlit;

// All entity types available as enum
var extractionTypes = new[]
{
    ObservableTypes.Person,
    ObservableTypes.Organization,
    ObservableTypes.Place,
    ObservableTypes.Event,
    ObservableTypes.Product,
    ObservableTypes.Repo,
    ObservableTypes.Software,
    ObservableTypes.Category,
    ObservableLabel,
    // Medical types
    ObservableTypes.MedicalCondition,
    ObservableTypes.MedicalDrug,
    // ... etc
};
````

### Developer Hints

#### Choose Relevant Types

```typescript
//  Don't extract everything
extractedTypes: [
  /* all 20+ types */
]
// Slow, expensive, noisy

// ✓ Extract what you need
extractedTypes: [
  ObservableTypes.Person,
  ObservableTypes.Organization
]
// Fast, focused, relevant
```

#### Schema.org Compliance

```typescript
// All types map to Schema.org
// Enables:
// - JSON-LD export
// - Standard property names
// - Interoperability with other tools
// - SEO-friendly structured data
```

#### Medical Types Fully Supported

```typescript
// Not beta - production ready
// All 12 medical types work
extractedTypes: [
  ObservableTypes.MedicalCondition,
  ObservableTypes.MedicalDrug,
  ObservableTypes.MedicalProcedure,
  // ... all 12 types available
]
```

### Common Issues & Solutions

**Issue**: Too many entities extracted (noise) **Solution**: Narrow down entity types

```typescript
//  Too broad
extractedTypes: [
  /* all types */
]

// ✓ Focused
extractedTypes: [
  ObservableTypes.Person,
  ObservableTypes.Organization
]
```

**Issue**: Missing entities **Solution**: Check if type is included

```typescript
// If you want products, must include:
extractedTypes: [
  ObservableTypes.Product  // Don't forget to add
]
```

**Issue**: Want custom entity types **Solution**: Currently limited to Schema.org types

```typescript
// Cannot create custom types
// Use closest Schema.org type
// Or use Category/Label for custom classifications
```

### Production Example

```typescript
async function demonstrateEntityTypes() {
  console.log('\n=== ENTITY TYPE DEMONSTRATION ===\n');
  
  // Create workflows for different domains
  
  // 1. Business workflow
  const businessWorkflow = await graphlit.createWorkflow({
    name: "Business Entity Extraction",
    extraction: {
      jobs: [{
        connector: {
          type: EntityExtractionServiceTypes.ModelText,
          extractedTypes: [
            ObservableTypes.Person,
            ObservableTypes.Organization,
            ObservableTypes.Place,
            ObservableTypes.Event,
            ObservableTypes.Product
          ]
        }
      }]
    }
  });
  console.log('✓ Created business workflow');
  
  // 2. Technical workflow
  const techWorkflow = await graphlit.createWorkflow({
    name: "Technical Entity Extraction",
    extraction: {
      jobs: [{
        connector: {
          type: EntityExtractionServiceTypes.ModelText,
          extractedTypes: [
            ObservableTypes.Software,
            ObservableTypes.Repo,
            ObservableTypes.Product,
            ObservableTypes.Organization,
            ObservableTypes.Person
          ]
        }
      }]
    }
  });
  console.log('✓ Created technical workflow');
  
  // 3. Medical workflow
  const medicalWorkflow = await graphlit.createWorkflow({
    name: "Medical Entity Extraction",
    extraction: {
      jobs: [{
        connector: {
          type: EntityExtractionServiceTypes.ModelText,
          extractedTypes: [
            ObservableTypes.MedicalCondition,
            ObservableTypes.MedicalDrug,
            ObservableTypes.MedicalProcedure,
            ObservableTypes.MedicalTest,
            ObservableTypes.MedicalStudy,
            ObservableTypes.Person,
            ObservableTypes.Organization
          ]
        }
      }]
    }
  });
  console.log('✓ Created medical workflow');
  
  console.log('\nEntity type counts by workflow:');
  console.log(`  Business: 5 types`);
  console.log(`  Technical: 5 types`);
  console.log(`  Medical: 7 types`);
  
  console.log('\nAll available types:');
  const allTypes = [
    'Person', 'Organization', 'Place', 'Event', 'Product',
    'Repo', 'Software', 'Category', 'Label',
    'MedicalCondition', 'MedicalDrug', 'MedicalDrugClass',
    'MedicalProcedure', 'MedicalTest', 'MedicalStudy',
    'MedicalDevice', 'MedicalTherapy', 'MedicalGuideline',
    'MedicalIndication', 'MedicalContraindication'
  ];
  console.log(`  Total: ${alllength} types`);
  console.log(`  ${alljoin(', ')}`);
}

await demonstrateEntityTypes();
```