Graphlit Platform

https://docs.graphlit.dev
Admin
Graphlit is a RAG-as-a-Service API for ingesting, retrieving, and managing knowledge for AI...
Tokens:297,425
Snippets:2,839
Trust Score:5.2
Update:2 months ago
Show doc for...
Tokens:
Raw
### Clone and Run Sample Project

Source: https://docs.graphlit.dev/examples/deep-research/mastra.md

Commands to clone the repository, install dependencies, and start the deep research sample.

```bash
git clone https://github.com/graphlit/graphlit-samples.git
cd graphlit-samples/nextjs/mastra-deep-research
pnpm install
cp .env.example .env
# Add your credentials
pnpm start --search "your query"
```

--------------------------------

### Install and Test MCP Server

Source: https://docs.graphlit.dev/mcp-integration/mcp-integration.md

Install the package globally and verify the installation with the test flag.

```bash
npm install -g graphlit-mcp-server
# or npx graphlit-mcp-server
npx graphlit-mcp-server --test
```

--------------------------------

### Initialize Project and Install Dependencies

Source: https://docs.graphlit.dev/getting-started/quickstart.md

Commands to create a new directory, initialize a Node.js project, and install the required Graphlit and OpenAI packages.

```bash
mkdir graphlit-quickstart && cd graphlit-quickstart
npm init -y
npm install graphlit-client dotenv tsx
npm install openai  # Needed for Steps 4-5 (streaming)
```

--------------------------------

### Install Graphlit Client

Source: https://docs.graphlit.dev/sdk-setup/for-python-developers.md

Use pip to install the required Graphlit client library.

```bash
pip install graphlit-client
```

--------------------------------

### Configure Preparation Stage

Source: https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/workflow-configure-entity-extraction.md

Example of setting up the file preparation stage for a workflow.

```typescript
preparation: {
  jobs: [{
    connector: {
      type: FilePreparationServiceTypes.Document,  // PDFs, Word, etc.
      // FilePreparationServiceTypes.Text for plain text
      // FilePreparationServiceTypes.Audio for transcription
    }
  }]
}
```

--------------------------------

### Initialize Project Dependencies

Source: https://docs.graphlit.dev/examples/deep-research/mastra.md

Install the necessary packages for Mastra, Graphlit, and CLI utilities.

```bash
mkdir deep-research && cd deep-research
pnpm init -y
pnpm add @mastra/core @ai-sdk/openai graphlit-client zod dotenv
pnpm add -D typescript tsx
pnpm add chalk ora boxen cli-table3 gradient-string
```

--------------------------------

### Install uv

Source: https://docs.graphlit.dev/examples/deep-research/agno.md

Command to install the uv package manager.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Initialize Project with pip

Source: https://docs.graphlit.dev/examples/deep-research/agno.md

Commands to create a virtual environment and install dependencies using pip.

```bash
mkdir deep-research && cd deep-research
python -m venv venv
source venv/bin/activate
pip install agno graphlit-client python-dotenv
```

--------------------------------

### Initialize Project with uv

Source: https://docs.graphlit.dev/examples/deep-research/agno.md

Commands to create a project directory and install necessary dependencies using uv.

```bash
mkdir deep-research && cd deep-research
uv init
uv add agno graphlit-client python-dotenv rich openai
```

--------------------------------

### Basic View Creation

Source: https://docs.graphlit.dev/api-guides/use-cases/views/view-create.md

A minimal example of creating a search view.

```typescript
const view = await graphlit.createView({
  name: 'My Search View',
  state: EntityState.Enabled
});

console.log(`View ID: ${view.createView.id}`);
```

--------------------------------

### Zendesk Articles Feed Configuration Examples

Source: https://docs.graphlit.dev/api-guides/use-cases/feeds/project-management/feed-create-zendesk-articles.md

Examples of configuring the Zendesk Articles feed for different organizational subdomains.

```typescript
type: FeedServiceTypes.ZendeskArticles,
subdomain: 'support'
```

```typescript
type: FeedServiceTypes.ZendeskArticles,
subdomain: 'docs'
```

```typescript
type: FeedServiceTypes.ZendeskArticles,
subdomain: 'help'
```

--------------------------------

### Workflow Query Examples

Source: https://docs.graphlit.dev/resources/ask-graphlit.md

Sample queries for requesting workflow configuration and usage code.

```text
How do I create a workflow?
Show me workflow with entity extraction
How do I use vision models for PDF extraction?
What workflow stages are available?
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.graphlit.dev/llms.txt

Perform a GET request to the documentation index using the ask and goal parameters to receive a direct answer with relevant excerpts.

```http
GET https://docs.graphlit.dev/platform/semantic-memory.md?ask=<question>&goal=<end_goal>
```

--------------------------------

### Production View System Example

Source: https://docs.graphlit.dev/api-guides/use-cases/views/view-create.md

Systematic creation of multiple search views for production environments.

```typescript
// Create views for different search contexts
const searchViews = [
  'Technical Documentation',
  'User Guides',
  'API Reference',
  'Troubleshooting',
  'Release Notes'
];

const createdViews: string[] = [];

for (const viewName of searchViews) {
  const view = await graphlit.createView({
    name: viewName,
    state: EntityState.Enabled
  });
  
  createdViews.push(view.createView.id);
  console.log(` Created view: ${viewName}`);
}

console.log(`\nCreated ${createdViews.length} search views`);
```

--------------------------------

### Production Content Analysis Example in TypeScript

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-metadata-structure.md

A comprehensive example showing how to switch on content types to extract specific metadata fields safely.

```typescript
async function analyzeContent(contentId: string) {
  const content = await graphlit.getContent(contentId);
  
  console.log(`\n=== CONTENT ANALYSIS ===`);
  console.log(`ID: ${content.content.id}`);
  console.log(`Name: ${content.content.name}`);
  console.log(`Type: ${content.content.type}`);
  console.log(`Created: ${content.content.creationDate}`);
  
  // Type-specific metadata
  switch (content.content.type) {
    case ContentTypes.Email:
      if (content.content.email) {
        console.log(`\n Email Metadata:`);
        console.log(`  From: ${content.content.email.from[0].email}`);
        console.log(`  Subject: ${content.content.email.subject}`);
        console.log(`  Recipients: ${content.content.email.to?.length || 0}`);
        console.log(`  Labels: ${content.content.email.labels?.join(', ') || 'none'}`);
      }
      break;
      
    case ContentTypes.Message:
      if (content.content.message) {
        console.log(`\n💬 Message Metadata:`);
        console.log(`  Channel: ${content.content.message.channelName}`);
        console.log(`  Author: ${content.content.message.author?.name}`);
        console.log(`  Mentions: ${content.content.message.mentions?.length || 0}`);
      }
      break;
      
    case ContentTypes.File:
      if (content.content.fileType === FileTypes.Document && content.content.document) {
        console.log(`\n Document Metadata:`);
        console.log(`  Pages: ${content.content.document.pageCount}`);
        console.log(`  Words: ${content.content.document.wordCount}`);
        console.log(`  Author: ${content.content.document.author || 'Unknown'}`);
      } else if (content.content.fileType === FileTypes.Image && content.content.image) {
        console.log(`\n🖼 Image Metadata:`);
        console.log(`  Size: ${content.content.image.width}x${content.content.image.height}`);
        console.log(`  Camera: ${content.content.image.make} ${content.content.image.model}`);
      }
      break;
  }
  
  // Common properties
  console.log(`\nFile: ${content.content.fileName || 'N/A'}`);
  console.log(`Size: ${content.content.fileSize || 0} bytes`);
  console.log(`MIME: ${content.content.mimeType || 'N/A'}`);
}
```

--------------------------------

### Initialize Graphlit Client

Source: https://docs.graphlit.dev/sdk-setup/for-typescript-developers.md

Basic initialization examples for TypeScript, ESM, and CommonJS environments.

```typescript
import { Graphlit } from 'graphlit-client';

async function main() {
  const graphlit = new Graphlit();

  const response = await graphlit.ingestText(
    'Our AI agent needs persistent memory across sessions...',
    'Product Requirements',
  );

  console.log(`✅ Memory created: ${response.ingestText.id}`);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});
```

```javascript
import { Graphlit } from 'graphlit-client';

async function main() {
  const graphlit = new Graphlit();

  const response = await graphlit.ingestText(
    'Our AI agent needs persistent memory across sessions...',
    'Product Requirements'
  );

  console.log(`✅ Memory created: ${response.ingestText.id}`);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});
```

```javascript
require('dotenv/config');
const { Graphlit } = require('graphlit-client');

async function main() {
  const graphlit = new Graphlit();

  const response = await graphlit.ingestText(
    'Our AI agent needs persistent memory across sessions...',
    'Product Requirements'
  );

  console.log(`✅ Memory created: ${response.ingestText.id}`);
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});
```

--------------------------------

### Invoke Ask Graphlit in IDE

Source: https://docs.graphlit.dev/resources/ask-graphlit.md

Example syntax for querying the MCP server within an IDE.

```text
@ask-graphlit How do I ingest a PDF and extract entities?
```

--------------------------------

### Create OpenAI Specification

Source: https://docs.graphlit.dev/platform/specifications.md

Example of creating a completion specification using the GPT-4o model.

```typescript
const gpt4oSpec = await graphlit.createSpecification({
  name: 'GPT-4o Production',
  type: SpecificationTypes.Completion,
  serviceType: ModelServiceTypes.OpenAi,
  openAI: {
    model: OpenAiModels.Gpt4O_128K,
    temperature: 0.2,           // Mostly factual
    completionTokenLimit: 3000  // ~2250 words max
  }
});
```

--------------------------------

### Feeds & Connectors Query Examples

Source: https://docs.graphlit.dev/resources/ask-graphlit.md

Sample queries for requesting connector and feed integration code.

```text
How do I connect to Slack?
Show me code to sync Google Drive
How do I create a podcast RSS feed?
What OAuth connectors are available?
```

--------------------------------

### Define Repository Configuration

Source: https://docs.graphlit.dev/api-guides/use-cases/feeds/project-management/feed-create-github-issues.md

Examples of repository owner and name configurations for different use cases.

```typescript
repositoryOwner: 'facebook',
repositoryName: 'react'
```

```typescript
repositoryOwner: 'your-org',
repositoryName: 'your-product'
```

```typescript
repositoryOwner: 'company',
repositoryName: 'customer-support'
```

--------------------------------

### Query Specifications in Python

Source: https://docs.graphlit.dev/api-guides/use-cases/specifications/specification-query.md

Examples for listing all specifications and filtering by type using Python syntax.

```python
specs = await graphlit.querySpecifications()

print(f"Total specifications: {len(specs.specifications.results)}")

for spec in specs.specifications.results: print(f"- {spec.name} ({spec.type})")
```

```python
completion_specs = await graphlit.querySpecifications( filter=SpecificationFilterInput( types=[SpecificationTypes.Completion] ) )
```

--------------------------------

### Searching & Retrieval Query Examples

Source: https://docs.graphlit.dev/resources/ask-graphlit.md

Sample queries for requesting search and retrieval implementation details.

```text
How do I search across all my content?
Show me semantic search with filters in TypeScript
How do I search within specific collections?
What's the Python code to find content by entity?
```

--------------------------------

### Create Google Specification

Source: https://docs.graphlit.dev/platform/specifications.md

Example of creating a completion specification using the Gemini 2.5 Flash model.

```typescript
const geminiSpec = await graphlit.createSpecification({
  name: 'Gemini 2.5 Flash',
  type: SpecificationTypes.Completion,
  serviceType: ModelServiceTypes.Google,
  google: {
    model: GoogleModels.Gemini_2_5Flash,
    temperature: 0.3,
    completionTokenLimit: 8000,
    enableThinking: true,
    thinkingTokenLimit: 10000
  }
});
```

--------------------------------

### Install python-dotenv

Source: https://docs.graphlit.dev/sdk-setup/for-python-developers.md

Install the dependency required to load environment variables from a file.

```bash
pip install python-dotenv
```

--------------------------------

### Install Graphlit Client

Source: https://docs.graphlit.dev/why-graphlit.md

Use this command to install the official Graphlit TypeScript client package.

```typescript
npm install graphlit-client
```

--------------------------------

### Start Research in URL Mode

Source: https://docs.graphlit.dev/examples/deep-research/mastra.md

Initiates the research process starting from a specific source URL.

```bash
pnpm start --url "https://arxiv.org/abs/2005.11401"
```

--------------------------------

### Install Dotenv Dependency

Source: https://docs.graphlit.dev/getting-started/quickstart.md

Install the dotenv package via npm to resolve module not found errors.

```bash
npm install dotenv
```

--------------------------------

### Implement Multi-Job Preparation Pipeline

Source: https://docs.graphlit.dev/platform/workflows.md

Workflow configuration demonstrating how to apply different preparation methods based on file type.

```typescript
const workflow = await graphlit.createWorkflow({
  name: 'Multi-Format Processing',
  preparation: {
    jobs: [
      {
        // Job 1: PDFs with vision model
        connector: {
          type: FilePreparationServiceTypes.ModelDocument,
          fileTypes: [FileTypes.Document],
          modelDocument: { specification: { id: gpt4oSpecId } }
        }
      },
      {
        // Job 2: Audio with Deepgram
        connector: {
          type: FilePreparationServiceTypes.Deepgram,
          fileTypes: [FileTypes.Audio, FileTypes.Video],
          deepgram: {
            model: DeepgramModels.Nova2,
            enableSpeakerDiarization: true
          }
        }
      },
      {
        // Job 3: Images with Azure AI (default for everything else)
        connector: {
          type: FilePreparationServiceTypes.AzureDocumentIntelligence,
          fileTypes: [FileTypes.Image]
        }
      }
    ]
  }
});
```

--------------------------------

### Confidence Scoring Examples

Source: https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/workflow-extraction-how-it-works.md

Provides examples of how confidence scores are interpreted based on text clarity and context.

```typescript
// High confidence (0.9-1.0):
// "Kirk Marple is the CEO..."
// Clear, explicit, unambiguous

// Medium confidence (0.7-0.9):
// "Kirk mentioned that..."
// Implicit context, less clear

// Low confidence (0.5-0.7):
// "The CEO said..."
// Pronoun reference, ambiguous

// Very low confidence (<0.5):
// "He suggested..."
// Multiple possible referents
```

--------------------------------

### Create and use a preparation workflow in TypeScript

Source: https://docs.graphlit.dev/api-guides/use-cases/workflows/workflow-create-preparation.md

This example shows the full lifecycle of creating a specification, defining a preparation workflow, ingesting a PDF, and retrieving the resulting markdown.

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

const graphlit = new Graphlit();

// Step 1: Create specification for preparation model
const specificationResponse = await graphlit.createSpecification({
  name: 'GPT-4o Vision for PDFs',
  type: SpecificationTypes.Preparation,
  serviceType: ModelServiceTypes.OpenAi,
  openAI: {
    model: OpenAiModels.Gpt4O_128K
  }
});

const specId = specificationResponse.createSpecification.id;

// Step 2: Create preparation workflow
const workflowInput: WorkflowInput = {
  name: 'PDF Preparation with Vision',
  preparation: {
    jobs: [{
      connector: {
        type: FilePreparationServiceTypes.ModelDocument,
        modelDocument: {
          specification: { id: specId }
        }
      }
    }]
  }
};

const response = await graphlit.createWorkflow(workflowInput);
const workflowId = response.createWorkflow.id;

console.log(`Workflow created: ${workflowId}`);

// Step 3: Use workflow during PDF ingestion
const contentResponse = await graphlit.ingestUri(
  'https://example.com/document.pdf',
  undefined,  // name
  undefined,  // id
  undefined,  // identifier
  true,       // isSynchronous
  { id: workflowId }  // workflow
);

// Step 4: Get extracted markdown
const content = await graphlit.getContent(contentResponse.ingestUri.id);
console.log(content.content.markdown); // High-quality markdown from PDF
```

--------------------------------

### Create Specification and Workflow in C#

Source: https://docs.graphlit.dev/api-guides/use-cases/workflows/workflow-create-preparation.md

Demonstrates the equivalent setup for specifications and workflows using the C# SDK.

```csharp
using Graphlit;

var client = new Graphlit();

// Create specification
var specResponse = await graphlit.CreateSpecification(new SpecificationInput {
    Name = "GPT-4o Vision for PDFs",
    Type = SpecificationTypes.Preparation,
    ServiceType = ModelServiceTypes.OpenAi,
    OpenAI = new OpenAIModelPropertiesInput {
        Model = OpenAiModels.Gpt4O_128K
    }
});

// Create preparation workflow (PascalCase)
var workflowInput = new WorkflowInput {
    Name = "PDF Preparation with Vision",
    Preparation = new PreparationWorkflowStageInput {
        Jobs = new[] {
            new PreparationWorkflowJobInput {
                Connector = new FilePreparationConnectorInput {
                    Type = FilePreparationServiceTypes.ModelDocument,
                    ModelDocument = new ModelDocumentPreparationPropertiesInput {
                        Specification = new EntityReferenceInput {
                            Id = specResponse.CreateSpecification.Id
                        }
                    }
                }
            }
        }
    }
};

var response = await graphlit.CreateWorkflow(workflowInput);
var workflowId = response.CreateWorkflow.Id;
```

--------------------------------

### Exa Search Query Examples

Source: https://docs.graphlit.dev/api-guides/use-cases/feeds/web/feed-create-exa-search.md

Examples of natural language search queries for different research topics.

```typescript
text: 'transformer architecture improvements 2024'
```

```typescript
text: 'distributed systems consensus algorithms explained'
```

```typescript
text: 'startups using GraphQL in production'
```

```typescript
text: 'AI safety alignment research latest developments'
```

--------------------------------

### Implement the Research CLI

Source: https://docs.graphlit.dev/examples/deep-research/agno.md

Sets up an asynchronous CLI entry point using asyncio and rich for displaying agent responses.

```python
#!/usr/bin/env python3
import asyncio
import sys
from dotenv import load_dotenv
from rich.console import Console
from rich.panel import Panel

from .agent import research_agent

console = Console()


async def main():
    load_dotenv()
    
    # Parse args (same pattern as Mastra)
    url = None if "--url" not in sys.argv else sys.argv[sys.argv.index("--url") + 1]
    search_query = None if "--search" not in sys.argv else sys.argv[sys.argv.index("--search") + 1]
    
    # Comprehensive validation (env vars, args)
    # ... validation code ...
    
    # Polished header with rich
    console.print()
    console.print(Panel.fit(
        "[bold cyan]Deep Research Agent[/bold cyan]\n"
        "[dim]Powered by Agno + Graphlit[/dim]",
        border_style="cyan"
    ))
    console.print()
    
    console.print(f"[bold]🔍 Research Query:[/bold] '{search_query}'\n")
    console.print("[bold green]🚀 Starting research...[/bold green]\n")
    
    # Run agent with streaming
    await research_agent.aprint_response(prompt, stream=True)
    
    console.print("\n\n[bold green]✅ Research complete![/bold green]\n")


if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Implement Related Content Recommendations

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-query-similar.md

A production-ready example that fetches recommendations and formats them into a simplified object structure.

```typescript
async function getRecommendations(articleId: string) {
  const similar = await graphlit.queryContents({
    contents: [{ id: articleId }],
    searchType: SearchTypes.Vector,
    limit: 6
  });
  
  const recommendations = similar.contents.results
    .filter(c => c.id !== articleId)
    .slice(0, 5);
  
  return recommendations.map(doc => ({
    id: doc.id,
    title: doc.name,
    summary: doc.summary?.substring(0, 150),
    uri: doc.uri
  }));
}

const recs = await getRecommendations('article-123');
console.log('You might also like:', recs);
```

--------------------------------

### RRF Scoring Example

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-search-hybrid-deep-dive.md

A conceptual example showing how vector and keyword search results are combined using RRF.

```typescript
// Query: "machine learning"

// Vector search results (semantic):
1. "ML Applications" (rank 1)
2. "AI Algorithms" (rank 2)
3. "Deep Learning Guide" (rank 3)

// Keyword search results (exact match):
1. "Machine Learning Basics" (rank 1)
2. "ML Applications" (rank 2)  // Also in vector!
3. "Learn Machine Learning" (rank 3)

// RRF scoring:
"ML Applications":
  Vector: 1/(60+1) = 0.0164
  Keyword: 1/(60+2) = 0.0161
  Combined: 0.0325 (highest!)
  
"Machine Learning Basics":
  Vector: not in top results = 0
  Keyword: 1/(60+1) = 0.0164
  Combined: 0.0164
  
"AI Algorithms":
  Vector: 1/(60+2) = 0.0161
  Keyword: not in top results = 0
  Combined: 0.0161

// Final ranking:
1. "ML Applications" (0.0325) - appears in BOTH
2. "Machine Learning Basics" (0.0164)
3. "AI Algorithms" (0.0161)
```

--------------------------------

### Install and Run Deep Research with pip

Source: https://docs.graphlit.dev/examples/deep-research/agno.md

Install the package in editable mode and run the research agent with a specific URL.

```bash
pip install -e .
deep-research --url "https://en.wikipedia.org/wiki/RAG"
```

--------------------------------

### Initialize Graphlit Client

Source: https://docs.graphlit.dev/sdk-setup/for-python-developers.md

Basic setup to initialize the client and ingest text content using environment variables.

```python
import asyncio
import os
from graphlit import Graphlit
from graphlit_api import *

async def main():
    # Reads from environment variables automatically
    graphlit = Graphlit()
    
    # Ingest content
    response = await graphlit.client.ingest_text(
        name="Product Requirements",
        text="Our AI agent needs persistent memory across sessions..."
    )
    
    print(f"✅ Memory created: {response.ingest_text.id}")

asyncio.run(main())
```

--------------------------------

### Initialize Graphlit Client with IConfiguration

Source: https://docs.graphlit.dev/sdk-setup/for-dotnet-developers.md

Build a configuration object and inject the credentials into the Graphlit client constructor.

```csharp
using Microsoft.Extensions.Configuration;

var config = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .AddEnvironmentVariables()  // Overrides appsettings
    .AddUserSecrets<Program>()  // Development secrets
    .Build();

using var httpClient = new HttpClient();
var graphlit = new Graphlit(
    httpClient,
    organizationId: config["Graphlit:OrganizationId"],
    environmentId: config["Graphlit:EnvironmentId"],
    jwtSecret: config["Graphlit:JwtSecret"]
);
```

--------------------------------

### Query and Search Workflows in C#

Source: https://docs.graphlit.dev/api-guides/use-cases/workflows/workflow-query.md

Provides a comprehensive example of querying, searching, and retrieving workflows using the C# SDK.

```csharp
using Graphlit;

var client = new Graphlit();

// Query all workflows (PascalCase)
var workflows = await graphlit.QueryWorkflows();

Console.WriteLine($"Total workflows: {workflows.Workflows.Results.Count}");

foreach (var workflow in workflows.Workflows.Results)
{
    Console.WriteLine($"- {workflow.Name} ({workflow.State})");
}

// Search by name
var searchResults = await graphlit.QueryWorkflows(new WorkflowFilter {
    Search = "Extraction"
});

// Get specific workflow
var workflow = await graphlit.GetWorkflow(workflowId);
Console.WriteLine($"Workflow: {workflow.Workflow.Name}");
```

--------------------------------

### Get Collection Details

Source: https://docs.graphlit.dev/api-guides/use-cases/collections/collection-query.md

Retrieve specific metadata for a collection.

```typescript
const collection = await graphlit.getCollection(collectionId);

console.log(`Collection: ${collection.collection.name}`);
console.log(`ID: ${collection.collection.id}`);
console.log(`Created: ${collection.collection.creationDate}`);
console.log(`State: ${collection.collection.state}`);
```

--------------------------------

### Query Project Usage and Credits in C#

Source: https://docs.graphlit.dev/api-guides/use-cases/production/project-query-usage.md

Demonstrates usage and credit queries using PascalCase methods in the C# SDK.

```csharp
using Graphlit;

var client = new Graphlit();

// Query usage (PascalCase)
var startDate = new DateTime(2024, 1, 1);
var endDate = DateTime.Now;

var usageResponse = await graphlit.QueryProjectUsage(
    startDate: startDate,
    endDate: endDate
);

Console.WriteLine("=== PROJECT USAGE ===");
Console.WriteLine($"API Calls: {usageResponse.Usage?.Count ?? 0}");

// Query credits
var creditsResponse = await graphlit.QueryProjectCredits();

Console.WriteLine("
=== CREDITS ===");
Console.WriteLine($"Remaining: ${creditsResponse.Credits?.Remaining ?? 0}");
Console.WriteLine($"Total: ${creditsResponse.Credits?.Total ?? 0}");
```

--------------------------------

### Expected Streaming Output

Source: https://docs.graphlit.dev/getting-started/quickstart.md

Example of the real-time token output format.

```text
Transformer attention is a mechanism that allows the model to focus on different
parts of the input when processing each token. Think of it like highlighting the
most relevant words in a sentence when trying to understand each word's meaning.
[complete]
```

--------------------------------

### Query and Search Workflows in Python

Source: https://docs.graphlit.dev/api-guides/use-cases/workflows/workflow-query.md

Demonstrates listing all workflows, searching by name, and retrieving a specific workflow by ID.

```python
workflows = await graphlit.queryWorkflows()

print(f"Total workflows: {len(workflows.workflows.results)}")

for workflow in workflows.workflows.results: print(f"- {workflow\.name} ({workflow\.state})")
```

```python
search_results = await graphlit.queryWorkflows( filter=WorkflowFilterInput( search="Extraction" ) )
```

```python
workflow = await graphlit.getWorkflow(workflow_id) print(f"Workflow: {workflow\.workflow\.name}")
```

--------------------------------

### Ingestion Query Examples

Source: https://docs.graphlit.dev/resources/ask-graphlit.md

Sample queries for requesting ingestion-related code and guidance.

```text
How do I ingest a PDF from a URL?
Show me TypeScript code to create an RSS feed
How do I upload a file and wait for it to finish processing?
Give me Python code to ingest Slack messages
```

--------------------------------

### CLI Progress Output

Source: https://docs.graphlit.dev/examples/deep-research/mastra.md

Example of the terminal output displayed during agent execution.

```text
╭────────────────────────────────╮
│ Deep Research Agent            │
│ Powered by Mastra + Graphlit  │
╰────────────────────────────────╯

🔍 Research Query: "knowledge graph embeddings"

✅ searchWeb
✅ ingestBatch
✅ extractEntities
✅ filterSearchResults (kept 4/10)
✅ detectDiminishingReturns (novelty: 0.42 - continue)
✅ generateReport
✅ Complete!
```

--------------------------------

### Create Entity Extraction Workflow in C#

Source: https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/workflow-configure-entity-extraction.md

Demonstrates creating a workflow using PascalCase methods.

```csharp
using Graphlit;
using Graphlit.Api.Input;

var graphlit = new Graphlit();

// Key differences: PascalCase methods
var workflow = await graphlit.CreateWorkflow(
    name: "Entity Extraction Workflow",
    preparation: new WorkflowPreparationInput
    {
        Jobs = new[]
        {
            new WorkflowPreparationJobInput
            {
                Connector = new FilePreparationConnectorInput
                {
                    Type = FilePreparationServiceText
                }
            }
        }
    },
    extraction: new WorkflowExtractionInput
    {
        Jobs = new[]
        {
            new WorkflowExtractionJobInput
            {
                Connector = new ExtractionConnectorInput
                {
                    Type = ExtractionServiceModelText,
                    ExtractedTypes = new[]
                    {
                        ObservableTypes.Person,
                        ObservableTypes.Organization,
                        ObservableTypes.Place,
                        ObservableTypes.Event
                    }
                }
            }
        }
    }
);

Console.WriteLine($"Created workflow: {workflow.CreateWorkflow.Id}");
```

--------------------------------

### Initialize Graphlit client and ingest text

Source: https://docs.graphlit.dev/sdk-setup/for-dotnet-developers.md

Demonstrates client initialization using environment variables and a basic text ingestion operation.

```csharp
using System;
using System.Net.Http;
using System.Threading.Tasks;
using Graphlit;

class Program
{
    static async Task Main(string[] args)
    {
        // Reads from environment variables
        using var httpClient = new HttpClient();
        var graphlit = new Graphlit(
            httpClient,
            organizationId: Environment.GetEnvironmentVariable("GRAPHLIT_ORGANIZATION_ID"),
            environmentId: Environment.GetEnvironmentVariable("GRAPHLIT_ENVIRONMENT_ID"),
            jwtSecret: Environment.GetEnvironmentVariable("GRAPHLIT_JWT_SECRET")
        );
        
        // Ingest content
        var response = await graphlit.IngestText.ExecuteAsync(
            name: "Product Requirements",
            text: "Our AI agent needs persistent memory across sessions..."
        );
        
        response.EnsureNoErrors();
        
        Console.WriteLine($"✅ Memory created: {response.Data?.IngestText?.Id}");
    }
}
```

--------------------------------

### Transcript Markdown Format

Source: https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/knowledge-graph-from-meetings.md

Example structure of the generated meeting transcript in Markdown.

```markdown
# Meeting Transcript

## Segment 1 (00:00 - 00:15)
Speaker 1: Welcome everyone to the Q4 planning meeting...

## Segment 2 (00:15 - 00:45)
Speaker 2: Thanks Kirk. I wanted to discuss the product roadmap...

## Segment 3 (00:45 - 01:20)
Speaker 1: Great points. Let's talk about the Graphlit launch timeline...
```

--------------------------------

### Medium Query Patterns

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-query-performance-patterns.md

Examples of queries that typically execute between 50ms and 200ms.

```typescript
// 1. Vector search
const medium1 = await graphlit.queryContents({
  search: "machine learning applications",
  searchType: SearchTypes.Vector,
  limit: 20
});

// 2. Hybrid search (default)
const medium2 = await graphlit.queryContents({
  search: "AI research",
  searchType: SearchTypes.Hybrid,
  limit: 20
});

// 3. Large result sets
const medium3 = await graphlit.queryContents({
  
    types: [ContentTypes.File]
  
  limit: 100
});
```

--------------------------------

### Manage Content Lifecycle in Production

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-lifecycle-states.md

A comprehensive example demonstrating how to handle different content states and perform state-specific logic.

```typescript
async function manageContentLifecycle(contentId: string) {
  const content = await graphlit.getContent(contentId);
  
  console.log(`\n=== CONTENT LIFECYCLE ===`);
  console.log(`ID: ${content.content.id}`);
  console.log(`Name: ${content.content.name}`);
  console.log(`Current State: ${content.content.state}`);
  console.log(`Created: ${content.content.creationDate}`);
  
  // State-based actions
  switch (content.content.state) {
    case EntityState.Created:
      console.log('\n⏳ Processing...');
      const isDone = await graphlit.isContentDone(contentId);
      if (isDone.isContentDone.result) {
        console.log('✓ Processing complete');
      } else {
        console.log('Still processing workflow');
      }
      break;
      
    case EntityState.Enabled:
      console.log('\n✓ Active and searchable');
      
      // Check if old enough to archive
      const age = Date.now() - new Date(content.content.creationDate).getTime();
      const daysOld = age / (1000 * 60 * 60 * 24);
      
      if (daysOld > 365) {
        console.log(`📦 Content is ${Math.floor(daysOld)} days old - consider archiving`);
      }
      break;
      
    case EntityState.Disabled:
      console.log('\n🔒 Hidden (soft deleted)');
      console.log('Can be restored with state: ENABLED');
      break;
      
    case EntityState.Archived:
      console.log('\n📦 Archived');
      console.log('Preserved for compliance, not actively used');
      break;
  }
  
  return content.content.state;
}

// Usage
await manageContentLifecycle('content-id');
```

--------------------------------

### Manage Content States in C#

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-lifecycle-states.md

Comprehensive example demonstrating state management operations using the C# SDK.

```csharp
using Graphlit;

var client = new Graphlit();

// Check state
var content = await graphlit.GetContent("content-id");
Console.WriteLine($"State: {content.Content.State}");

// Update state (PascalCase)
await graphlit.UpdateContent(new ContentUpdateInput
{
    Id = "content-id",
    State = EntityState.Disabled
});

// Query by state
var results = await graphlit.QueryContents(new ContentFilter
{
    States = new[] { EntityState.Enabled }
});
```

--------------------------------

### Fast Query Patterns

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-query-performance-patterns.md

Examples of high-performance queries that typically execute in under 50ms.

```typescript
// 1. Keyword search with indexed filters
const fast1 = await graphlit.queryContents({
  search: "PROJ-1234",
  searchType: SearchTypes.Keyword,
  
    types: [ContentTypes.File],
    creationDateRange: { from: '2024-01-01' }
  
  limit: 20
});

// 2. Metadata-only filter (no search)
const fast2 = await graphlit.queryContents({
  
    types: [ContentTypes.Email],
    feeds: [{ id: 'feed-id' }],
    createdInLast: 'P7D'
  });

// 3. Get by ID (single result)
const fast3 = await graphlit.getContent('content-id');
```

--------------------------------

### Create View in C#

Source: https://docs.graphlit.dev/api-guides/use-cases/views/view-create.md

Demonstrates creating a view using PascalCase naming conventions.

```csharp
using Graphlit;

var client = new Graphlit();

// Create view (PascalCase)
var viewInput = new ViewInput {
    Name = "Product Documentation Search",
    State = EntityState.Enabled
};

var response = await graphlit.CreateView(viewInput);
var viewId = response.CreateView.Id;

Console.WriteLine($"View created: {viewId}");
```

--------------------------------

### Trello Feed Configuration Examples

Source: https://docs.graphlit.dev/api-guides/use-cases/feeds/project-management/feed-create-trello.md

Common configuration patterns for different project management use cases.

```typescript
type: TrelloTypes.Board,
identifiers: ['product-roadmap-board-id']
```

```typescript
type: TrelloTypes.Board,
identifiers: ['sprint-board-id', 'backlog-board-id']
```

```typescript
type: TrelloTypes.Board,
identifiers: ['client-projects-board-id']
```

--------------------------------

### Configure Domain-Specific Entity Extraction

Source: https://docs.graphlit.dev/examples/deep-research/agno.md

Examples of defining extracted_types for different research domains.

```python
extracted_types=[
    ObservableTypes.MEDICALCONDITION,
    ObservableTypes.DRUG,
    ObservableTypes.PERSON,  # Researchers
]
```

```python
extracted_types=[
    ObservableTypes.LEGALCASE,
    ObservableTypes.CONTRACT,
    ObservableTypes.ORGANIZATION,  # Law firms
]
```

```python
extracted_types=[
    ObservableTypes.PRODUCT,
    ObservableTypes.EVENT,
    ObservableTypes.ORGANIZATION,  # Companies
]
```

--------------------------------

### Create and Manage Collections with TypeScript

Source: https://docs.graphlit.dev/api-guides/use-cases/collections/collection-create-and-manage.md

Demonstrates the workflow for creating a collection, associating content items with it, and querying the collection contents.

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

const graphlit = new Graphlit();

// Create collection
const collection = await graphlit.createCollection({
  name: "Q4 Reports",
  description: "Financial reports for Q4 2024"
});

const collectionRef: EntityReferenceInput = {
  id: collection.createCollection.id,
};

// Add content to collection
await graphlit.addContentsToCollections(
  [
    { id: 'content-1' },
    { id: 'content-2' },
    { id: 'content-3' },
  ],
  [collectionRef]
);

// Query collection
const contents = await graphlit.queryContents({
  collections: [collectionRef]
});

console.log(`Collection has ${contents.contents.results.length} items`);
```

--------------------------------

### Clone and Run Agno Deep Research Sample

Source: https://docs.graphlit.dev/examples/deep-research/agno.md

Commands to clone the repository, install dependencies, and execute the deep research agent.

```bash
git clone https://github.com/graphlit/graphlit-samples.git
cd graphlit-samples/python/agno-deep-research
uv sync
cp .env.example .env
# Add credentials
uv run python -m deep_research.main --search "your query"
```

--------------------------------

### Create View in Python

Source: https://docs.graphlit.dev/api-guides/use-cases/views/view-create.md

Demonstrates creating a view using snake_case naming conventions.

```python
view_input = input_types.ViewInput( name="Product Documentation Search", state=enums.EntityState.ENABLED )

response = await graphlit.createView(view_input) view_id = response.create_view.id

print(f"View created: {view_id}")
```

--------------------------------

### Conversations & RAG Query Examples

Source: https://docs.graphlit.dev/resources/ask-graphlit.md

Sample queries for requesting conversation and RAG-related code.

```text
How do I create a conversation in TypeScript?
Show me streaming conversation code
Give me the C# version of tool calling with conversations
What's the difference between promptConversation and streamAgent?
```

--------------------------------

### Ingest Content

Source: https://docs.graphlit.dev/sdk-setup/for-typescript-developers.md

Examples of ingesting content from a URI or raw text into the Graphlit system.

```typescript
// From URL
const pdf = await graphlit.ingestUri(
  'https://example.com/document.pdf',
  'Product Brief',
  undefined, // id
  undefined, // identifier
  true,      // isSynchronous
);

console.log(`📄 PDF ready: ${pdf.ingestUri.id}`);

// From text
const notes = await graphlit.ingestText(
  'Discussion about Q4 planning...',
  'Meeting Notes',
);

console.log(`📝 Notes ready: ${notes.ingestText.id}`);
```

--------------------------------

### C# Implementation for Observations

Source: https://docs.graphlit.dev/api-guides/use-cases/knowledge-graph/observable-observation-model-explained.md

Complete C# example demonstrating content retrieval, iteration, and observable lookup.

```csharp
using Graphlit;

var client = new Graphlit();

// Get content with observations
var content = await graphlit.GetContent("content-id");

Console.WriteLine($"Content: {content.Content.Name}");
Console.WriteLine($"Observations: {content.Content.Observations?.Length ?? 0}");

// Iterate observations
foreach (var obs in content.Content.Observations ?? Array.Empty<Observation>())
{
    Console.WriteLine($"\nEntity: {obs.Observable.Name}");
    Console.WriteLine($"Type: {obs.Type}");
    Console.WriteLine($"Entity ID: {obs.Observable.Id}");
    
    // Occurrences
    foreach (var occ in obs.Occurrences ?? Array.Empty<ObservationOccurrence>())
    {
        Console.WriteLine($"  Page: {occ.PageIndex}");
        Console.WriteLine($"  Confidence: {occ.Confidence}");
    }
}

// Get observable
var observable = await graphlit.GetObservable("observable-id");
Console.WriteLine($"Observable: {observable.Observable.Name}");
```

--------------------------------

### Ingest Content Patterns

Source: https://docs.graphlit.dev/sdk-setup/for-python-developers.md

Examples for ingesting content from either a URI or raw text.

```python
# From URL
response = await graphlit.client.ingest_uri(
    uri="https://example.com/document.pdf"
)

# From text
response = await graphlit.client.ingest_text(
    name="Meeting Notes",
    text="Discussion about Q4 planning..."
)
```

--------------------------------

### Create View for Specific Context

Source: https://docs.graphlit.dev/api-guides/use-cases/views/view-create.md

Example of creating a view for a specific search context.

```typescript
// Create view for specific search context
const view = await graphlit.createView({
  name: 'Customer Support Search',
  state: EntityState.Enabled
});

// Views can be referenced in queries
// Actual behavior depends on your Graphlit configuration
```

--------------------------------

### Update Specification Variations

Source: https://docs.graphlit.dev/api-guides/use-cases/specifications/specification-update.md

Specific examples for updating temperature or token limits individually.

```typescript
await graphlit.updateSpecification({
  id: specId,
  openAI: {
    temperature: 0.1  // More focused
  }
});
```

```typescript
await graphlit.updateSpecification({
  id: specId,
  openAI: {
    completionTokenLimit: 4000  // Longer responses
  }
});
```

--------------------------------

### Create a Web Crawl Feed for Documentation

Source: https://docs.graphlit.dev/api-guides/use-cases/feeds/web/feed-create-web-crawl.md

Demonstrates the full lifecycle of creating a collection, a preparation workflow, and a web crawl feed, followed by status monitoring and RAG query execution.

```typescript
// 1. Create collection
const collection = await graphlit.createCollection({
  name: 'Product Documentation'
});

// 2. Create preparation workflow
const workflow = await graphlit.createWorkflow({
  name: 'Web Prep',
  preparation: {
    jobs: [{
      connector: {
        type: FilePreparationServiceTypes.ModelDocument,
        modelDocument: {
          specification: { id: visionSpecId }
        }
      }
    }]
  }
});

// 3. Create web crawl feed
const feed = await graphlit.createFeed({
  name: 'Documentation Crawl',
  type: FeedTypes.Web,
  web: {
    uri: 'https://docs.example.com',
    readLimit: 1000,
    includeFiles: true,
    allowedDomains: ['docs.example.com'],
    excludedPaths: ['/api/', '/admin/', '/login/']
  },
  collections: [{ id: collection.createCollection.id }],
  workflow: { id: workflow.createWorkflow.id }
});

// 4. Wait for crawl
console.log('Starting crawl...');
const feedId = feed.createFeed.id;
let isDone = false;
let checkCount = 0;

while (!isDone) {
  const status = await graphlit.isFeedDone(feedId);
  isDone = status.isFeedDone.result || false;
  
  if (!isDone) {
    checkCount++;
    
    // Show progress
    const crawled = await graphlit.queryContents({
      feeds: [{ id: feedId }]
    });
    
    console.log(`Check ${checkCount}: ${crawled.contents.results.length} pages crawled so far...`);
    await new Promise(resolve => setTimeout(resolve, 30000)); // 30 seconds
  }
}

console.log(' Crawl complete!');

// 5. Get final stats
const pages = await graphlit.queryContents({
  feeds: [{ id: feedId }],
  types: [ContentTypes.Page]
});

const files = await graphlit.queryContents({
  feeds: [{ id: feedId }],
  types: [ContentTypes.File]
});

console.log(`\nCrawl Results:`);
console.log(`- ${pages.contents.results.length} pages`);
console.log(`- ${files.contents.results.length} files`);

// 6. Enable RAG queries
const answer = await graphlit.promptConversation({
  prompt: 'How do I configure authentication?',
  collections: [{ id: collection.createCollection.id }]
});

console.log(`\nRAG Answer: ${answer.message.message}`);
```

--------------------------------

### Update Specification (snake_case)

Source: https://docs.graphlit.dev/api-guides/use-cases/specifications/specification-update.md

Example of updating a specification using snake_case naming conventions.

```python
await graphlit.updateSpecification( specification=SpecificationUpdateInput( id=spec_id, open_ai=OpenAiModelPropertiesInput( temperature=0.2, completion_token_limit=2000 ) ) )
```

--------------------------------

### Implementing Pagination

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-query-with-filters.md

Example of fetching paginated results using offset and limit parameters.

```typescript
// Fetch first page
let offset = 0;
const limit = 20;

const page1 = await graphlit.queryContents({
  search: 'meeting notes',
  offset: 0,
  limit: limit
});

// Fetch second page
const page2 = await graphlit.queryContents({
  search: 'meeting notes',
  offset: limit,  // offset = 20
  limit: limit
});

// Continue until results.length < limit
```

--------------------------------

### Query and Access Metadata in C#

Source: https://docs.graphlit.dev/api-guides/use-cases/content/content-document-metadata-queries.md

Full example for querying documents, filtering by extension, and iterating through results to access metadata.

```csharp
using Graphlit;

var client = new Graphlit();

// Query documents
var docs = await graphlit.QueryContents(new ContentFilter
{
    Filter = new ContentCriteria
    {
        Types = new[] { ContentTypes.File },
        FileTypes = new[] { FileDocument }
    }
});

// PDFs only
var pdfs = await graphlit.QueryContents(new ContentFilter
{
    Filter = new ContentCriteria
    {
        FileExtensions = new[] { "pdf" }
    }
});

// Access metadata
foreach (var doc in docs.Contents.Results)
{
    if (doc.Document != null)
    {
        Console.WriteLine($"{doc.Name}: {doc.Document.PageCount} pages");
        Console.WriteLine($"  Author: {doc.Document.Author}");
        Console.WriteLine($"  Words: {doc.Document.WordCount}");
    }
}
```
Tokens:
Raw