# Create Semantic Search View

## View: Create Semantic Search View

### User Intent

"I want to create a reusable search configuration for semantic queries"

### Operation

* **SDK Method**: `graphlit.createView()`
* **GraphQL**: `createView` mutation
* **Entity Type**: View
* **Common Use Cases**: Saved search configurations, preset filters, reusable query templates

### TypeScript (Canonical)

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

const graphlit = new Graphlit();

// Create semantic search view
const viewInput: ViewInput = {
  name: 'Product Documentation Search',
  state: EntityState.Enabled
};

const response = await graphlit.createView(viewInput);
const viewId = response.createView.id;

console.log(`View created: ${viewId}`);

// Use view in queries (views configure search behavior)
// Note: View functionality depends on your Graphlit configuration
const searchResults = await graphlit.queryContents({
  search: 'API authentication',
  searchType: SearchTypes.Hybrid
});

console.log(`Found ${searchResults.contents.results.length} results`);
```

## Create view (snake\_case)

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}")

````

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

### Parameters

#### ViewInput (Required)

* **`name`** (string): View name
* **`state`** (EntityState): View state
  * `ENABLED` or `DISABLED`

### Response

```typescript
{
  createView: {
    id: string;           // View ID
    name: string;         // View name
    state: EntityState;   // View state
    creationDate: Date;   // Creation timestamp
  }
}
```

### Developer Hints

#### Views for Preset Configurations

**Views** are used to create reusable search configurations:

```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
```

**Important**: Views are organizational entities for search configuration management.

#### View Management

```typescript
// Create views for different search contexts
const views = {
  docs: await graphlit.createView({
    name: 'Documentation Search',
    state: EntityState.Enabled
  }),
  
  support: await graphlit.createView({
    name: 'Support Articles',
    state: EntityState.Enabled
  }),
  
  internal: await graphlit.createView({
    name: 'Internal Knowledge Base',
    state: EntityState.Enabled
  })
};

console.log('Created search views:');
Object.values(views).forEach(v => {
  console.log(`- ${v.createView.name} (${v.createView.id})`);
});
```

### Variations

#### 1. Basic View

Create simple view:

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

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

#### 2. Multiple Views

Create views for different purposes:

```typescript
const views = [
  { name: 'Product Docs', state: EntityState.Enabled },
  { name: 'API Reference', state: EntityState.Enabled },
  { name: 'Tutorials', state: EntityState.Enabled }
];

for (const viewConfig of views) {
  const view = await graphlit.createView(viewConfig);
  console.log(`Created: ${view.createView.name}`);
}
```

#### 3. Disabled View

Create but don't enable immediately:

```typescript
const view = await graphlit.createView({
  name: 'Future Search Config',
  state: EntityState.Disabled
});

// Enable later with updateView()
```

### Common Issues

**Issue**: Not sure how to use views\
**Solution**: Views are organizational entities. Check your Graphlit configuration for view-specific features.

**Issue**: `View already exists` error\
**Solution**: View names must be unique. Use different name or query existing views first.

### Production Example

**Create view system**:

```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`);
```


---

# 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/views/view-create.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.