> ## Documentation Index
> Fetch the complete documentation index at: https://docs.corti.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Manage your library and access

> Organize your library, filter to find what you need, and control who can access your templates and sections.

## Overview

Once you have built templates and sections, your library is where you keep them organized and decide who can use them. This guide covers two things:

* Filtering your library to quickly find a template or section.
* Assigning customer access, for Embedded Assistant integrations.

If you are still building, see [Build a template](/textgen/console-templates/build-a-template) and [Build a section](/textgen/console-templates/build-a-section).

## Find what you need by filtering

Open **Templates** in Corti Console. {/* TODO: link to the Console Templates page */} A tab switcher moves between the **Templates** and **Sections** libraries. Both show the templates and sections you have created alongside Corti standards.

As your library grows, use the filters to narrow it down:

* **Type:** show all, only Corti templates and sections, or only your custom templates and sections.
* **Language**
* **Regions**
* **Specialty**
* **Custom properties** you have added, such as a Department property.

Filtering helps you find a good starting point to copy, locate a resource you want to edit, or pick out the templates you want to assign access to. To add these properties to a template or section, see [Build a template](/textgen/console-templates/build-a-template) and [Build a section](/textgen/console-templates/build-a-section).

## Manage access

<Note>
  **Access management in Corti Console is for Embedded Assistant integrations.**
  It lets you decide which of your customers, and their users, can see and use a
  given template or section. If you integrate directly through the API, see
  [Access for direct API integrations](#access-for-direct-api-integrations)
  below.
</Note>

### Customers and users

If you use the Embedded Assistant, you manage two groups in Corti Console:

* **Customers:** your customers, such as hospitals.
* **Users:** the end users of the Embedded Assistant, such as clinicians and doctors. Each user belongs to a customer.

Access is assigned at the project or customer level and cascades down to users. You cannot assign access to individual users from Console.

### Assign access to customers

Open the access dialog for the custom template or section you want to share. You can do this in two ways:

* From the library overview, select the **Access** icon button next to the custom template or section.
* From the **details page** of any template or section, which opens the same dialog.

In the dialog, assign or unassign access by choosing who can use it:

| Access                                   | Who can use the template or section                                                       |
| ---------------------------------------- | ----------------------------------------------------------------------------------------- |
| **Whole project**                        | Every customer in the project and all of their users.                                     |
| **Specific customer(s)**                 | Only the named customers, and all of their users.                                         |
| **No customer access** (default for new) | Only API clients in your project. Not exposed to any Embedded Assistant customer or user. |

A newly created template or section starts with no customer access, so nothing is exposed to your customers or their users until you assign it.

<Info>
  **Corti standards are a special case.** They are available to all customers in
  a project, and this access cannot be changed.
</Info>

### Access for direct API integrations

If you integrate directly through the API rather than the Embedded Assistant, Corti has no concept of your customers or end users, so access management is entirely on your side. By default, your templates and sections are available to all API clients in your project.

How you organize and expose them is up to you. For example, you might filter by properties and custom properties to keep things organized, or maintain your own mapping of template IDs to customers in your own system. The access controls described above apply only to Embedded Assistant integrations.

## What's next

<CardGroup cols={2}>
  <Card title="Build a template" href="/textgen/console-templates/build-a-template">
    Create and customize your templates.
  </Card>

  <Card title="Build a section" href="/textgen/console-templates/build-a-section">
    Create and customize the building blocks.
  </Card>

  <Card title="Intro to guided templates and sections" href="/textgen/console-templates/get-started">
    The bigger picture.
  </Card>

  <Card title="Guided Document Synthesis" href="/textgen/documents-guided-synthesis">
    Generate documents from your templates through the API.
  </Card>
</CardGroup>

## FAQ

<AccordionGroup>
  <Accordion title="Can I control customer access if I only use the API?">
    No. The Console access controls are for Embedded Assistant integrations,
    where Corti knows about your customers and users. With a direct API
    integration there are no customers or users in Corti, so you manage exposure
    in your own system. See [Access for direct API
    integrations](#access-for-direct-api-integrations).
  </Accordion>

  <Accordion title="Why can't I change who sees a Corti standard?">
    Corti standards are available to all customers in a project by design, and
    this access is fixed. If you need a version with restricted access, copy the
    standard (**Edit a copy**) and assign access to your own copy. See [Build a
    template](/textgen/console-templates/build-a-template) or [Build a
    section](/textgen/console-templates/build-a-section).
  </Accordion>
</AccordionGroup>