# Query Workflows

## Workflow: Query Workflows

### User Intent

"I want to list all my workflows or find a specific workflow by name"

### Operation

* **SDK Method**: `graphlit.queryWorkflows()` or `graphlit.getWorkflow()`
* **GraphQL**: `queryWorkflows` or `getWorkflow` query
* **Entity Type**: Workflow
* **Common Use Cases**: List workflows, find workflow by name, check workflow configuration

### TypeScript (Canonical)

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

const graphlit = new Graphlit();

// Query all workflows
const workflows = await graphlit.queryWorkflows();

console.log(`Total workflows: ${workflows.workflows.results.length}`);

workflows.workflows.results.forEach(workflow => {
  console.log(`- ${workflow.name} (${workflow.state})`);
});

// Search by name
const searchResults = await graphlit.queryWorkflows({
  search: 'Extraction'
});

console.log(`\nFound ${searchResults.workflows.results.length} extraction workflows`);

// Get specific workflow
// Replace with ID from creating a workflow or from queryWorkflows results above
const workflowId = 'workflow-id-here';
const workflow = await graphlit.getWorkflow(workflowId);

console.log(`\nWorkflow: ${workflow.workflow.name}`);
console.log(`Created: ${workflow.workflow.creationDate}`);

// Check workflow type
if (workflow.workflow.extraction) {
  console.log('Type: Extraction workflow');
  console.log(`Jobs: ${workflow.workflow.extraction.jobs?.length || 0}`);
} else if (workflow.workflow.preparation) {
  console.log('Type: Preparation workflow');
  console.log(`Jobs: ${workflow.workflow.preparation.jobs?.length || 0}`);
}
```

## Query all workflows (snake\_case)

workflows = await graphlit.queryWorkflows()

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

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

## Search by name

search\_results = await graphlit.queryWorkflows( filter=WorkflowFilterInput( search="Extraction" ) )

## Get specific workflow

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

````

**C#**:
```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}");
````

### Parameters

#### queryWorkflows (Optional Filter)

* **`search`** (string): Search by workflow name
* **`states`** (EntityState\[]): Filter by state
  * `ENABLED`, `DISABLED`

#### getWorkflow (Required)

* **`id`** (string): Workflow ID

### Response

```typescript
{
  workflows: {
    results: Workflow[];
  }
}

interface Workflow {
  id: string;
  name: string;
  state: EntityState;
  creationDate: Date;
  preparation?: PreparationWorkflowStage;
  extraction?: ExtractionWorkflowStage;
}
```

### Developer Hints

#### Workflow Types

**Three main workflow types**:

```typescript
// Preparation workflow (PDF, audio, video)
if (workflow.workflow.preparation) {
  console.log('Preparation workflow');
}

// Extraction workflow (entities, knowledge graph)
if (workflow.workflow.extraction) {
  console.log('Extraction workflow');
}

// Combined workflow (both stages)
if (workflow.workflow.preparation && workflow.workflow.extraction) {
  console.log('Combined workflow');
}
```

#### Find Workflow by Name

```typescript
const results = await graphlit.queryWorkflows({
  search: 'PDF Preparation'
});

if (results.workflows.results.length > 0) {
  const workflow = results.workflows.results[0];
  console.log(`Found: ${workflow.name} (${workflow.id})`);
} else {
  console.log('Workflow not found');
}
```

#### Workflow Inventory

```typescript
const workflows = await graphlit.queryWorkflows();

const byType = {
  preparation: 0,
  extraction: 0,
  combined: 0
};

workflows.workflows.results.forEach(w => {
  if (w.preparation && w.extraction) {
    byType.combined++;
  } else if (w.preparation) {
    byType.preparation++;
  } else if (w.extraction) {
    byType.extraction++;
  }
});

console.log('Workflow Inventory:');
console.log(`  Preparation: ${byType.preparation}`);
console.log(`  Extraction: ${byType.extraction}`);
console.log(`  Combined: ${byType.combined}`);
```

### Variations

#### 1. List All Workflows

Get all workflows:

```typescript
const workflows = await graphlit.queryWorkflows();
console.log(`You have ${workflows.workflows.results.length} workflows`);
```

#### 2. Search by Name

Find specific workflows:

```typescript
const results = await graphlit.queryWorkflows({
  search: 'Entity Extraction'
});

console.log('Extraction workflows:');
results.workflows.results.forEach(w => {
  console.log(`- ${w.name}`);
});
```

#### 3. Get Workflow Details

Retrieve full configuration:

```typescript
const workflow = await graphlit.getWorkflow(workflowId);

console.log(`Workflow: ${workflow.workflow.name}`);
console.log(`State: ${workflow.workflow.state}`);
console.log(`Created: ${workflow.workflow.creationDate}`);

if (workflow.workflow.extraction) {
  console.log(`\nExtraction Jobs: ${workflow.workflow.extraction.jobs?.length || 0}`);
}

if (workflow.workflow.preparation) {
  console.log(`Preparation Jobs: ${workflow.workflow.preparation.jobs?.length || 0}`);
}
```

#### 4. Filter Active Workflows

Only enabled workflows:

```typescript
const active = await graphlit.queryWorkflows({
  states: [EntityState.Enabled]
});

console.log(`Active workflows: ${active.workflows.results.length}`);
```

#### 5. Workflow Summary Report

Generate workflow summary:

```typescript
const workflows = await graphlit.queryWorkflows();

console.log('=== WORKFLOW SUMMARY ===\n');

for (const w of workflows.workflows.results) {
  const fullWorkflow = await graphlit.getWorkflow(w.id);
  
  console.log(`📋 ${fullWorkflow.workflow.name}`);
  console.log(`   ID: ${fullWorkflow.workflow.id}`);
  console.log(`   State: ${fullWorkflow.workflow.state}`);
  
  if (fullWorkflow.workflow.preparation) {
    console.log(`   Type: Preparation`);
    console.log(`   Jobs: ${fullWorkflow.workflow.preparation.jobs?.length || 0}`);
  }
  
  if (fullWorkflow.workflow.extraction) {
    console.log(`   Type: Extraction`);
    console.log(`   Jobs: ${fullWorkflow.workflow.extraction.jobs?.length || 0}`);
  }
  
  console.log('');
}
```

### Common Issues

**Issue**: `Workflow not found` error\
**Solution**: Verify workflow ID is correct. Workflow may have been deleted.

**Issue**: Search returns no results\
**Solution**: Search is case-sensitive. Try partial matches.

**Issue**: Can't determine workflow type\
**Solution**: Check `preparation` and `extraction` properties. One or both will be present.

### Production Example

**Workflow management dashboard**:

```typescript
const workflows = await graphlit.queryWorkflows();

console.log('=== WORKFLOW DASHBOARD ===\n');

for (const w of workflows.workflows.results) {
  const full = await graphlit.getWorkflow(w.id);
  
  let type = 'Unknown';
  if (full.workflow.preparation && full.workflow.extraction) {
    type = 'Preparation + Extraction';
  } else if (full.workflow.preparation) {
    type = 'Preparation';
  } else if (full.workflow.extraction) {
    type = 'Extraction';
  }
  
  const status = full.workflow.state === EntityState.Enabled ? '' : '';
  
  console.log(`${status} ${full.workflow.name}`);
  console.log(`   Type: ${type}`);
  console.log(`   Created: ${new Date(full.workflow.creationDate).toLocaleDateString()}\n`);
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.graphlit.dev/api-guides/use-cases/workflows/workflow-query.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.