# Query Collections

## Collection: Query Collections

### User Intent

"I want to list all my collections or find a specific collection by name"

### Operation

* **SDK Method**: `graphlit.queryCollections()` or `graphlit.getCollection()`
* **GraphQL**: `queryCollections` or `getCollection` query
* **Entity Type**: Collection
* **Common Use Cases**: List collections, find collection by name, check collection contents

### TypeScript (Canonical)

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

const graphlit = new Graphlit();

// Query all collections
const collections = await graphlit.queryCollections();

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

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

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

console.log(`\nFound ${searchResults.collections.results.length} documentation collections`);

// Get specific collection
// Replace with ID from creating a collection or from queryCollections results above
const collectionId = 'collection-id-here';
const collection = await graphlit.getCollection(collectionId);

console.log(`\nCollection: ${collection.collection.name}`);
console.log(`Created: ${collection.collection.creationDate}`);

// Count content in collection
const contents = await graphlit.queryContents({
  collections: [{ id: collectionId }]
});

console.log(`Content items: ${contents.contents.results.length}`);
```

## Query all collections (snake\_case)

collections = await graphlit.queryCollections()

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

for coll in collections.collections.results: print(f"- {coll.name} ({coll.state})")

## Search by name

search\_results = await graphlit.queryCollections( filter=input\_types.CollectionFilter( search="Documentation" ) )

## Get specific collection

collection = await graphlit.getCollection(collection\_id) print(f"Collection: {collection.collection.name}")

````

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

var client = new Graphlit();

// Query all collections (PascalCase)
var collections = await graphlit.QueryCollections();

Console.WriteLine($"Total collections: {collections.Collections.Results.Count}");

foreach (var coll in collections.Collections.Results)
{
    Console.WriteLine($"- {coll.Name} ({coll.State})");
}

// Search by name
var searchResults = await graphlit.QueryCollections(new CollectionFilter {
    Search = "Documentation"
});

// Get specific collection
var collection = await graphlit.GetCollection(collectionId);
Console.WriteLine($"Collection: {collection.Collection.Name}");
````

### Parameters

#### queryCollections (Optional Filter)

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

#### getCollection (Required)

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

### Response

```typescript
{
  collections: {
    results: Collection[];
  }
}

interface Collection {
  id: string;
  name: string;
  state: EntityState;
  creationDate: Date;
}
```

### Developer Hints

#### Collections Don't Store Content Count

**Important**: Collections don't have a built-in content count. Query contents to count.

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

// Count items in collection
const contents = await graphlit.queryContents({
  collections: [{ id: collectionId }]
});

console.log(`${collection.collection.name}: ${contents.contents.results.length} items`);
```

#### Find Collection by Name

```typescript
const results = await graphlit.queryCollections({
  search: 'Product Docs'
});

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

#### Collection Inventory

```typescript
const collections = await graphlit.queryCollections();

console.log('=== COLLECTION INVENTORY ===\n');

for (const coll of collections.collections.results) {
  const contents = await graphlit.queryContents({
    collections: [{ id: coll.id }],
    limit: 1  // Just get count
  });
  
  console.log(`${coll.name}:`);
  console.log(`  Items: ${contents.contents.results.length}`);
  console.log(`  State: ${coll.state}\n`);
}
```

### Variations

#### 1. List All Collections

Get all collections:

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

#### 2. Search by Name

Find specific collections:

```typescript
const results = await graphlit.queryCollections({
  search: 'Documentation'
});

console.log('Documentation collections:');
results.collections.results.forEach(coll => {
  console.log(`- ${coll.name}`);
});
```

#### 3. Get Collection Details

Retrieve specific 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}`);
```

#### 4. Collection with Content Count

Show content counts:

```typescript
const collections = await graphlit.queryCollections();

for (const coll of collections.collections.results) {
  const contents = await graphlit.queryContents({
    collections: [{ id: coll.id }]
  });
  
  console.log(`${coll.name}: ${contents.contents.results.length} items`);
}
```

#### 5. Filter Active Collections

Only enabled collections:

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

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

### Common Issues

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

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

**Issue**: Can't see content count\
**Solution**: Use `queryContents()` with collection filter to count items.

### Production Example

**Collection dashboard**:

```typescript
const collections = await graphlit.queryCollections();

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

for (const coll of collections.collections.results) {
  const contents = await graphlit.queryContents({
    collections: [{ id: coll.id }]
  });
  
  const fileCount = contents.contents.results.filter(
    c => c.type === ContentTypes.File
  ).length;
  
  const pageCount = contents.contents.results.filter(
    c => c.type === ContentTypes.Page
  ).length;
  
  console.log(` ${coll.name}`);
  console.log(`   Total: ${contents.contents.results.length} items`);
  console.log(`   Files: ${fileCount}, Pages: ${pageCount}`);
  console.log(`   State: ${coll.state}\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/collections/collection-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.