### Ejento AI Reasoning Modes Configuration

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This example shows how to select reasoning modes (ReAct, Reflection, CodeAct) during assistant creation in Ejento AI. It highlights the configuration options within the UI and provides a tooltip example for the CodeAct mode, emphasizing its capabilities for data analysis and visualization.

```bash
# Configuration during assistant creation:
# - Navigate to "More Options" in assistant creation
# - Select Reasoning Pattern:
#   [ReAct] [Reflection] [CodeAct]
# - Example: Select "CodeAct" for data analysis assistant
# - Tooltip: "Enables code execution for data processing and visualization"
# - Create assistant
```

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

### Create Multi-Assistant Workflow (Bash)

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This guide outlines the process of creating multi-assistant workflows in Ejento AI, focusing on intelligent routing and consolidation. It details how to configure a workflow, add specialized assistants, and select a supervisor type (Router, Consolidator, or Dynamic Supervisor) based on use cases and query complexity. Testing the workflow with example queries is also included.

```bash
# Navigate to Workflows
# UI Path: Sidebar → Workflows → Add Workflow

# Workflow Configuration:
# - Workflow Name: "Customer Support Workflow"
# - Description: "Routes queries to specialized assistants"
# - Add Assistants:
#   1. "Product Documentation Assistant"
#   2. "Billing Support Assistant"
#   3. "Technical Troubleshooting Assistant"

# Supervisor Type Selection:

# Option 1: Router
# - Analyzes query and routes to single best assistant
# - Use case: Queries have clear domain (billing vs technical)
# - Example query: "How do I cancel my subscription?"
# - Behavior: Routes to "Billing Support Assistant" only
# - Response: Single answer from most relevant assistant

# Option 2: Consolidator
# - Sends query to all assistants and aggregates responses
# - Use case: Complex queries requiring multiple perspectives
# - Example query: "What's the complete process for upgrading my plan?"
# - Behavior: Queries all three assistants
# - Response: Combined answer referencing billing, features, and technical steps

# Option 3: Dynamic Supervisor
# - Decides between Router or Consolidator based on query complexity
# - Use case: Mixed query types with varying complexity
# - Example simple query: "What's your refund policy?"
# - Behavior: Acts as Router → single assistant response
# - Example complex query: "I need to upgrade and migrate my data"
# - Behavior: Acts as Consolidator → aggregated response

# Create workflow and test:
# - Click "Create Workflow"
# - Navigate to workflow chat
# - Submit query: "I need help with API integration and billing"
# - Dynamic Supervisor consolidates responses from relevant assistants
```

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

### Ejento AI API Response Example

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This is an example of a typical JSON response received from the Ejento AI API after a successful request. It includes details about the message ID, assistant ID, the generated response, any sources used, and the number of tokens consumed.

```json
{
  "id": "msg_xyz789",
  "assistant_id": "ast_abc123xyz",
  "response": "The system requirements are...",
  "sources": [
    {
      "document_id": "doc_123",
      "title": "System Requirements Guide",
      "excerpt": "Minimum requirements include..."
    }
  ],
  "tokens_used": 156
}
```

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

### Create Assistant in Ejento AI Platform

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This snippet details the steps for creating an intelligent assistant in the Ejento AI Platform, including configuration of custom instructions, visibility, conversation starters, and reasoning modes (ReAct, Reflection, CodeAct). It outlines the UI path and provides examples for each configuration aspect, highlighting the use case for ReAct mode in documentation queries.

```bash
# Navigate to Assistants
# UI Path: Sidebar → Assistants → Add Assistant

# Configuration:
# - Select Team: "Customer Support"
# - Select Project: "Product Documentation Assistant"
# - Assistant Name: "Product Help Bot"
# - Description: "Answers product-related questions using documentation"
# - Role Definition: "You are a helpful product support assistant"

# Custom Instructions:
# - Click "Add Custom Instruction"
# - Instruction: "Always provide code examples when explaining features"
# - Instruction: "Include relevant documentation links in responses"
# - Click "Save"

# Visibility Options:
# - Only Me: Visible only to creator
# - Only Team: Visible to all team members
# - Public: Accessible via shareable link

# Conversation Starters:
# - "How do I reset my password?"
# - "What are the system requirements?"
# - "How do I integrate the API?"

# Reasoning Mode Selection:
# - ReAct: For queries requiring external tools (web search, RAG, files)
# - Reflection: For complex reasoning with self-revision capabilities
# - CodeAct: For code execution, data analysis, and file generation

# Example: ReAct mode for documentation queries
# - Reasoning Mode: ReAct
# - Enables: Web search, RAG retrieval, file attachments
# - Use case: Retrieving and synthesizing information from docs

# Click "Create assistant"
```

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

### Create Team in Ejento AI Platform

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This snippet outlines the steps to create a new team within the Ejento AI Platform using the UI. It details the navigation path and essential settings for team creation, including name and default roles. It also explains the available team roles and provides an example of adding a team member.

```bash
# Navigate to Teams section and create a new team
# UI Path: Sidebar → Teams → Add Team
# Team settings:
# - Team Name: "Customer Support"
# - Team Owner: Automatically assigned to creator
# - Default Role: Team Viewer (read-only access to assistants)

# Team roles:
# - Team Owner: Full access to all assistants, projects, and team settings
# - Team Viewer: Can view and chat with assistants but cannot edit

# Example: Adding a team member
# UI: Teams → Select Team → Add User → Assign Role
# User Email: user@company.com
# Role: Team Viewer
```

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

### Configure Nginx ETags

Source: https://docshub.ejento.ai/tutorials/etag-setup-corpus-incremental-refresh

These snippets configure Nginx for ETag handling. The first enables ETags globally. The second enables ETags for specific file types like HTML and adds a no-cache header. The third shows how to load a dynamic ETag module for dynamic responses.

```nginx
etag on;
```

```nginx
location ~* \.html$ {
  etag on;
  add_header Cache-Control "no-cache";
}
```

```nginx
load_module modules/ngx_http_dynamic_etag_module.so;
```

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

### Enable ETags in Nginx

Source: https://docshub.ejento.ai/tutorials/etag-setup-corpus-incremental-refresh

Enables ETags globally in Nginx using the 'etag on' directive. This setting controls the generation of ETags for all responses. Note that Gzip compression can interfere with ETag accuracy.

```nginx
etag on;
```

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

### Ejento AI API Request Example using cURL

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This snippet demonstrates how to make a POST request to the Ejento AI API to send a message to an assistant. It includes setting the necessary headers for authorization and content type, and provides a sample JSON payload. Ensure you replace placeholder values with your actual tenant name, API key, and access token.

```bash
curl -X POST "https://your-tenant.api.ejento.ai/v1/chat/completions" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." \
  -H "X-API-Key: sk_live_abc123xyz789def456" \
  -H "Content-Type: application/json" \
  -d '{
    "assistant_id": "ast_abc123xyz",
    "message": "What are the system requirements?",
    "stream": false
  }'
```

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

### Configure Apache FileETag

Source: https://docshub.ejento.ai/tutorials/etag-setup-corpus-incremental-refresh

Configures Apache's FileETag directive to use MTime and Size for ETag generation, ensuring consistency. This helps control how ETags are created based on file properties.

```apache
FileETag MTime Size Header
```

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

### Enable ETags in Node.js Express

Source: https://docshub.ejento.ai/tutorials/etag-setup-corpus-incremental-refresh

This snippet demonstrates how to enable ETag generation in a Node.js Express application. It shows setting the etag option for the application and for serving static files, which helps in efficient caching and revalidation.

```javascript
app.set('etag', 'strong'); // or 'weak'
app.use(express.static('public', { etag: true }));
```

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

### Add ETag Support in Spring Boot

Source: https://docshub.ejento.ai/tutorials/etag-setup-corpus-incremental-refresh

Integrates ETag support into Spring Boot applications using the `ShallowEtagHeaderFilter`. This filter adds ETags to REST responses, enhancing cache validation mechanisms.

```java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.ShallowEtagHeaderFilter;

@Configuration
public class WebConfig {

    @Bean
    public ShallowEtagHeaderFilter shallowEtagHeaderFilter() {
        return new ShallowEtagHeaderFilter();
    }
}
```

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

### Add ETag Support in Spring Boot (Java)

Source: https://docshub.ejento.ai/tutorials/etag-setup-corpus-incremental-refresh

This Java code snippet shows how to add ETag support to a Spring Boot application using `ShallowEtagHeaderFilter`. This filter automatically generates ETags based on the response content, aiding in conditional requests and caching.

```java
@Bean
public Filter shallowEtagHeaderFilter() {
    return new ShallowEtagHeaderFilter();
}
```

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

### Enable ETags in Express (Node.js)

Source: https://docshub.ejento.ai/tutorials/etag-setup-corpus-incremental-refresh

Sets Express to use 'strong' ETags for improved caching control. This leverages the built-in support within the Express framework for generating ETags on REST API responses.

```javascript
app.set('etag', 'strong');
```

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

### Embed Assistant as Chat Widget (Bash)

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This section explains how to embed an Ejento AI assistant as a chat widget on external websites. It covers enabling public access for the assistant, retrieving the embed code, and provides an example of the JavaScript snippet to be included in the website's HTML. Customization options via data attributes are also listed.

```bash
# Navigate to Assistant
# UI Path: Assistants → Three Dots → Edit

# Enable public access:
# - Scroll to "More Options"
# - Enable "Public Link" toggle
# - Click "Update assistant"

# Get embed code:
# - Click Share icon on assistant
# - Click "Embed this assistant"
# - Embed code copied to clipboard

# Example embed code (paste in website HTML):
<script>
  (function() {
    var script = document.createElement('script');
    script.src = 'https://app.ejento.ai/embed.js';
    script.setAttribute('data-assistant-id', 'ast_abc123xyz');
    script.setAttribute('data-theme', 'light');
    document.body.appendChild(script);
  })();
</script>

# Customization options (data attributes):
# - data-theme: "light" or "dark"
# - data-position: "bottom-right" or "bottom-left"
# - data-primary-color: "#4F46E5"
# - data-greeting: "Hi! How can I help you?"

# Widget appears as floating chat button on website
# Users can interact without leaving the page
```

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

### PII Redaction Audit Log Statistics

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

Provides an example of an audit log entry for PII redaction, showcasing statistics related to the process. It includes the total number of documents processed, the count of PII entities found, and a breakdown of these entities by type, offering insights into the effectiveness and scope of redaction efforts.

```text
# Audit log:
# - View redaction statistics
# - Documents processed: 1,234
# - PII entities found: 5,678
# - Entity breakdown:
#   - EMAIL_ADDRESS: 2,345
#   - PHONE_NUMBER: 1,456
#   - PERSON: 1,234
#   - SSN: 643
```

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

### Configure Apache HTTP Server ETags

Source: https://docshub.ejento.ai/tutorials/etag-setup-corpus-incremental-refresh

This snippet configures Apache HTTP Server to generate ETags based on file modification time and size, ensuring consistency across servers by ignoring inode values. It's crucial for the Incremental Refresh feature to function correctly.

```apache
FileETag MTime Size
Header set ETag "%{MTime}e-%{Size}e"
```

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

### Example of PII Redaction in Ejento AI Output

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

Illustrates how PII redaction is applied to a sample text document. It shows the original text containing various sensitive data types and the corresponding redacted version using the 'Entity Type Labeling' strategy. This highlights how sensitive information is masked with entity type labels in assistant responses and processed documents.

```text
# Example redacted document:
# Original text:
# "Customer John Smith (john.smith@email.com, 555-123-4567)
#  reported issue with account #4532-1234-5678-9012.
#  SSN: 123-45-6789"

# After redaction:
# "Customer {{PERSON}} ({{EMAIL_ADDRESS}}, {{PHONE_NUMBER}})
#  reported issue with account #{{CREDIT_CARD}}.
#  SSN: {{SSN}}"
```

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

### Configure PII Redaction Settings in Ejento AI

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This section details how to enable and configure PII (Personally Identifiable Information) redaction within the Ejento AI platform. It covers UI navigation, enabling auto-detection, selecting PII entity types to redact, and choosing between different redaction strategies like full redaction, partial redaction, or entity type labeling. The configuration example shows how to apply these settings to new or all documents.

```bash
# Navigate to Corpus PII Settings
# UI Path: Assistants → View Corpora → View Corpus → Settings → PII Redaction

# Enable PII Redaction:
# - Toggle: "Enable PII Detection" → ON
# - Auto-detect: Email addresses, phone numbers, SSNs, credit cards

# PII Entity Types:
# - PERSON: Names of individuals
# - EMAIL_ADDRESS: Email addresses
# - PHONE_NUMBER: Phone numbers
# - CREDIT_CARD: Credit card numbers
# - SSN: Social Security Numbers
# - DATE_OF_BIRTH: Birth dates
# - ADDRESS: Physical addresses
# - MEDICAL_RECORD: Healthcare identifiers

# Redaction Options:

# Option 1: Full Redaction
# - Original: "Contact John Doe at john.doe@company.com"
# - Redacted: "Contact [REDACTED] at [REDACTED]"

# Option 2: Partial Redaction (preserve context)
# - Original: "Contact John Doe at john.doe@company.com"
# - Redacted: "Contact [PERSON] at [EMAIL]"

# Option 3: Entity Type Labeling
# - Original: "Contact John Doe at john.doe@company.com"
# - Redacted: "Contact {{PERSON}} at {{EMAIL_ADDRESS}}"

# Configuration:
# - Select redaction strategy: "Entity Type Labeling"
# - Select entity types to redact:
#   [x] PERSON
#   [x] EMAIL_ADDRESS
#   [x] PHONE_NUMBER
#   [x] SSN
#   [x] CREDIT_CARD
#   [ ] DATE (keep dates visible)
# - Apply to: "New documents only" or "All documents"
# - Click "Save Configuration"
```

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

### Create Project in Ejento AI Platform

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This snippet describes the process of creating a new project within a team in the Ejento AI Platform. It includes the UI navigation path and the necessary information for project creation, such as selecting a team, project name, and description. It emphasizes that projects act as containers for assistants with shared context.

```bash
# Navigate to Projects section
# UI Path: Sidebar → Projects → Add Project

# Project creation:
# - Select Team: "Customer Support"
# - Project Name: "Product Documentation Assistant"
# - Description: "Assistant for product manual queries"

# Projects serve as containers for assistants with shared context
# Multiple assistants can exist within a single project
```

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

### API Keys and Authentication

Source: https://docshub.ejento.ai/tutorials/apikeys

This section details how to access the Developer Portal, create new API keys with different permission scopes, and obtain your authentication token for API access.

```APIDOC
## API Keys and Authentication

### Description
This section guides you through managing your API subscription keys and obtaining your authentication token. It covers accessing the Developer Portal, creating new API keys with specific permissions, and understanding the scopes (All, Read Only, Restricted).

### Guides

1.  **Accessing the Developer Portal**:
    *   Login to your account.
    *   Navigate to the **API KEYS** section from the dashboard.
    *   Alternatively, go to the Admin Panel > Settings > API Keys.

2.  **Creating a New API Key**:
    *   Click on "Create new secret key".
    *   Name your key.
    *   Select the desired permission scope: **All**, **Read Only**, or **Restricted**.
        *   **Restricted** permissions allow category-level access control (None, Read, Write).
    *   Click "Create".
    *   Follow the link to allow access and activate your key.
    *   Copy and save your secret key (it will only be shown once).

3.  **Obtaining Authentication Token**:
    *   From the API KEYS section in the Developer Portal, copy your auth token.
    *   This token is needed in the header as a Bearer token for API requests.

4.  **Server URL**:
    *   From the API KEYS section, copy your server URL.
    *   This URL will be used as the `baseURL` when making API calls.
```

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

### Reasoning Modes Configuration

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

Overview of different reasoning modes available for assistants and how to configure them.

```APIDOC
## Reasoning Modes Overview

### Description
This section details the different reasoning modes (ReAct, Reflection, CodeAct) available for configuring assistant behavior, including their capabilities, use cases, and limitations.

### Reasoning Modes:

1.  **ReAct Mode (Reasoning + Acting)**
    *   **Capabilities**: Step-by-step reasoning, dynamic tool selection (Web Search, RAG, File Attachments), information retrieval and synthesis.
    *   **Use cases**: Querying for latest information, searching documentation, retrieving data from knowledge bases.
    *   **Limitations**: Cannot execute code, cannot generate downloadable files, no iterative self-revision.

2.  **Reflection Mode**
    *   **Capabilities**: Self-evaluation and revision of responses, uses external tools, multiple iteration cycles, enhanced accuracy.
    *   **Use cases**: Complex question answering, comparing concepts, detailed explanations.
    *   **Limitations**: Cannot execute code, cannot generate downloadable files, no real-time computations.

3.  **CodeAct Mode**
    *   **Capabilities**: Python code generation and execution, data analysis, visualization, file generation (CSV, Excel, PDF), graph creation.
    *   **Use cases**: Data analysis, generating reports, creating charts, processing structured data.
    *   **Limitations**: Cannot access the internet or search the web, cannot use external tools (Web Search, RAG), no real-time information retrieval.

### Configuration:
Reasoning modes are selected during assistant creation or editing via the "More Options" menu. The user selects one of the available patterns: [ReAct] [Reflection] [CodeAct].

### Mode Comparison Table:

| Feature                | ReAct | Reflection | CodeAct |
| :--------------------- | :---- | :--------- | :------ |
| Step-by-step reasoning | Yes   | Yes        | Yes     |
| External tools         | Yes   | Yes        | No      |
| Self-revision          | No    | Yes        | No      |
| Code execution         | No    | No         | Yes     |
| Data analysis          | No    | No         | Yes     |
| File generation        | No    | No         | Yes     |
```

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

### Upload Documents to Ejento AI Corpus

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This snippet explains how to set up a corpus and index documents within the Ejento AI Platform. It covers multiple methods for document upload: drag-and-drop, browsing local files (supporting various formats), and adding web links for bulk indexing. It also includes instructions for deleting documents and the UI navigation path.

```bash
# Navigate to Assistant Corpus
# UI Path: Assistants → Three Dots → View Corpora → View Corpus

# Upload Documents:
# Method 1: Drag and drop files directly into corpus view

# Method 2: Browse files
# - Click "Add" → "Browse Files"
# - Supported formats: PDF, Word, Excel, CSV, PPTX, RTF, EML, EPUB,
#   XML, KML, GZ, JSON, Text, HTML, Zip, OpenDocument
# - Select files → "Upload File(s)"

# Method 3: Add web links
# - Click "Add" → "Links"
# - Enter URLs (one per line for bulk indexing):
#   https://docs.company.com/api/v1
#   https://docs.company.com/api/v2
#   https://docs.company.com/tutorials
# - Click "Upload Link(s)"

# Document status shows "Completed" when indexed
# Assistant can now retrieve information from uploaded documents

# Delete documents:
# - Corpus Settings → "Delete documents" → Confirm
```

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

### Create Custom Tool Connector (Bash)

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This snippet details the steps to create a custom tool connector using the Model Context Protocol (MCP). It covers navigating to the tools section, configuring tool details, selecting categories, adding optional settings like website and icon URLs, and including authentication headers if necessary. The tool is then connected to an assistant.

```bash
# Navigate to Tools
# UI Path: Sidebar → Tools → Connectors → Add Custom Connector

# Tool Configuration:
# - Tool Name: "BookManager"
# - Tool Description: "Manages book inventory and recommendations"
# - MCP Server URL: "https://api.bookmanager.com/mcp"
# - Transport: "HTTP"
# - System Prompt: "This tool provides book inventory data and recommendation algorithms"

# Category Selection:
# - Select Category: "Productivity"
# - Categories organize tools in the connector library

# Additional Settings:
# - Website: "https://bookmanager.com"
# - Icon URL: "https://bookmanager.com/icon.png"
# - Headers (if authentication required):
#   - Header Name: "Authorization"
#   - Header Value: "Bearer sk_live_abc123xyz789"

# Click "Create Connector"
# Tool appears in both Connectors and Tools tabs

# Connect tool to assistant:
# - Navigate to Assistant → Edit
# - Tools section → Enable "BookManager"
# - Assistant can now invoke tool during conversations

# Disconnect tool:
# - Tools → Connectors → Click "Connected" on tool
# - Click "Disconnect"
```

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

### Testing API Keys in the REST API Playground

Source: https://docshub.ejento.ai/tutorials/apikeys

Learn how to test your generated API keys and authentication tokens using the Ejento AI REST API Playground to experiment with different endpoints.

```APIDOC
## Testing API Keys in the REST API Playground

### Description
This guide explains how to use the Ejento AI REST API Playground to test your newly generated API keys and authentication tokens. You can experiment with API endpoints and view real-time responses.

### Steps

1.  **Access API Documentation**:
    *   Click on "View API documentation" to be redirected to Ejento APIs documentation.

2.  **Select an Endpoint**:
    *   Choose an API endpoint you wish to test.

3.  **Initiate Test**:
    *   Click on "Try it".

4.  **Configure Dynamic Base URL**:
    *   Click on the icon to configure variables.
    *   Click on the `your-server-name` variable to set your dynamic base URL.

5.  **Provide Credentials**:
    *   Replace the placeholder variables with your actual copied values:
        *   Replace `your-server-name` with the Server URL obtained in the API Keys section.
        *   Replace `your-api-key` with the secret API Key you created.
        *   Replace `your-access-token` with the Authorization Token you copied.

6.  **Execute Request**:
    *   Send the request to see the response.
```

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

### Teams App Manifest Configuration (manifest.json)

Source: https://docshub.ejento.ai/integrations/ms-teams-integration-setup

This JSON file defines the core properties of a Microsoft Teams application, including its name, description, icons, bot configuration, permissions, and valid domains. It serves as the blueprint for your Teams app.

```json
{
  "$schema": "https://developer.microsoft.com/en-us/json-schemas/teams/v1.16/MicrosoftTeams.schema.json",
  "manifestVersion": "1.16",
  "version": "1.1.5",
  "id": "YOUR_APP_CLIENT_ID",
  "packageName": "com.microsoft.teams.extension",
  "developer": {
    "name": "Data Science Dojo",
    "websiteUrl": "https://ejento.ai/",
    "privacyUrl": "https://ejento.ai/#/privacy-policy",
    "termsOfUseUrl": "https://ejento.ai/#/terms-of-use"
  },
  "icons": {
    "color": "YOUR_ICON_COLOR.png",
    "outline": "YOUR_ICON_OUTLINE.png"
  },
  "name": {
    "short": "YOUR_APP_NAME",
    "full": "YOUR_APP_NAME"
  },
  "description": {
    "short": "YOUR_APP_DESCRIPTION",
    "full": "YOUR_APP_DESCRIPTION"
  },
  "accentColor": "#FFFFFF",
  "bots": [
    {
      "botId": "YOUR_APP_CLIENT_ID",
      "scopes": ["personal", "team", "groupchat"],
      "commandLists": [
        {
          "scopes": ["personal", "team", "groupchat"],
          "commands": [
            {
              "title": "Configure agent",
              "description": "Set up other agents."
            },
            {
              "title": "Show agent",
              "description": "Show the configured agent."
            },
            {
              "title": "Reset",
              "description": "Reset the history of the agent."
            },
            {
              "title": "Help",
              "description": "Get help from documentation."
            }
          ]
        }
      ],
      "isNotificationOnly": false,
      "supportsCalling": false,
      "supportsVideo": false,
      "supportsFiles": true
    }
  ],
  "composeExtensions": [],
  "configurableTabs": [],
  "staticTabs": [],
  "permissions": ["identity", "messageTeamMembers"],
  "validDomains": ["token.botframework.com", "GET_DOMAIN_FROM_DSD"],
  "webApplicationInfo": {
    "id": "YOUR_APP_CLIENT_ID",
    "resource": "api://botid-YOUR_APP_CLIENT_ID"
  }
}
```

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

### Configure SharePoint Integration in Ejento AI Platform

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

This snippet describes the process of connecting SharePoint folders to the Ejento AI Platform for automatic document synchronization. It details the UI navigation path to the SharePoint integration settings and explains the functionality and access of the default SharePoint folder, which is automatically created and cannot be deleted.

```bash
# Navigate to SharePoint Integration
# UI Path: Assistants → Three Dots → View Corpora → View Corpus → Add Document → SharePoint

# Default SharePoint folder:
# - Automatically created when assistant is created
# - Cannot be deleted
# - Open via "Open Sharepoint URL" icon

# Upload to default folder:
```

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

### API Key Management

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

Endpoints and procedures for creating, managing, and revoking API keys.

```APIDOC
## Create New API Key

### Description
Allows users to create a new API key with specified permission scopes.

### Method
POST

### Endpoint
/api/keys (Hypothetical endpoint, as actual creation is UI-driven)

### Parameters
#### Request Body
- **name** (string) - Required - The name for the API key (e.g., "Production API Access").
- **scopes** (object) - Optional - Defines permission levels. Can be "all", "read_only", or a custom object with granular control.
  - **assistants** (string) - Optional - e.g., "write", "read", "none"
  - **teams** (string) - Optional - e.g., "write", "read", "none"
  - **users** (string) - Optional - e.g., "write", "read", "none"
  - **corpus** (string) - Optional - e.g., "write", "read", "none"
  - **analytics** (string) - Optional - e.g., "write", "read", "none"

### Request Example
```json
{
  "name": "Production API Access",
  "scopes": {
    "assistants": "write",
    "corpus": "write",
    "teams": "read",
    "users": "none",
    "analytics": "read"
  }
}
```

### Response
#### Success Response (201 Created)
- **key_id** (string) - The unique identifier for the created API key.
- **secret_key** (string) - The secret key associated with the API key (only shown once).

#### Response Example
```json
{
  "key_id": "key_abc123",
  "secret_key": "sk_live_abc123xyz789def456"
}
```

## Revoke API Key

### Description
Invalidates an existing API key, revoking all associated access.

### Method
DELETE

### Endpoint
/api/keys/{key_id} (Hypothetical endpoint, as actual revocation is UI-driven)

### Parameters
#### Path Parameters
- **key_id** (string) - Required - The unique identifier of the API key to revoke.

### Response
#### Success Response (204 No Content)
Indicates the key has been successfully revoked.

```

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

### App Package Structure for Teams

Source: https://docshub.ejento.ai/integrations/ms-teams-integration-setup

This illustrates the expected file structure for packaging a Microsoft Teams application. It requires a manifest file and icon images to be placed within a zip archive.

```file structure
appPackage.zip
├── manifest.json
├── yourlogo.png
└── youroutline.png
```

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

### Creating a New Thread and Submitting the Query Automatically

Source: https://docshub.ejento.ai/features/url-based-chatthread-creation

This endpoint allows for the creation of a new chat thread, prefilling the input with a query, and automatically submitting it after a short delay. The parameters are then removed from the URL.

```APIDOC
## GET /en/apps/agentChat

### Description
This endpoint allows you to initiate a new chat thread, prefill the chat input with a specific query, and automatically submit that query. It's useful for guiding users or automating initial interactions.

### Method
GET

### Endpoint
`/en/apps/agentChat`

### Query Parameters
- **id** (string) - Required - The unique identifier for the agent chat application.
- **thread** (string) - Required - Set to `new` to create a new chat thread.
- **query** (string) - Required - The query text to be prefilled and submitted.
- **submit** (boolean) - Required - Set to `true` to automatically submit the query after it's prefilled.

### Request Example
```
app.ejento.ai/en/apps/agentChat?id=U2FsdGVkX18QP2S4Cz&thread=new&query=How%20can%20I%20track%20my%20order&submit=true
```

### Response
#### Success Response (200)
This endpoint does not return a specific JSON response for success. Instead, it modifies the state of the chat application in the browser. The URL parameters (`thread`, `query`, `submit`) are removed after the query is submitted.

### Behavior Details
1. A new chat thread is initiated.
2. The chat input field is populated with the provided `query`.
3. After a 1000ms delay, the query is automatically submitted.
4. The `thread=new`, `query`, and `submit=true` parameters are removed from the URL to ensure a clean state.
```

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

### Chat Completions API

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

Endpoint for sending messages to an assistant and receiving responses.

```APIDOC
## Chat Completions

### Description
Sends a message to a specified assistant and retrieves a response. Supports streaming of responses.

### Method
POST

### Endpoint
/v1/chat/completions

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **assistant_id** (string) - Required - The ID of the assistant to interact with.
- **message** (string) - Required - The user's message or query.
- **stream** (boolean) - Optional - Defaults to `false`. If `true`, the response will be streamed.

### Request Example
```json
{
  "assistant_id": "ast_abc123xyz",
  "message": "What are the system requirements?",
  "stream": false
}
```

### Response
#### Success Response (200 OK)
- **id** (string) - Unique message ID.
- **assistant_id** (string) - The ID of the assistant that generated the response.
- **response** (string) - The assistant's generated response.
- **sources** (array) - An array of sources used to generate the response.
  - **document_id** (string) - The ID of the source document.
  - **title** (string) - The title of the source document.
  - **excerpt** (string) - A relevant excerpt from the source document.
- **tokens_used** (integer) - The number of tokens used for this interaction.

#### Response Example
```json
{
  "id": "msg_xyz789",
  "assistant_id": "ast_abc123xyz",
  "response": "The system requirements are...",
  "sources": [
    {
      "document_id": "doc_123",
      "title": "System Requirements Guide",
      "excerpt": "Minimum requirements include..."
    }
  ],
  "tokens_used": 156
}
```

#### Streamed Response Example (Partial)
```json
data: {"id": "msg_xyz789", "choices": [{"delta": {"role": "assistant"}, "finish_reason": null, "index": 0}]}

data: {"id": "msg_xyz789", "choices": [{"delta": {"content": "The "}, "finish_reason": null, "index": 0}]}

data: {"id": "msg_xyz789", "choices": [{"delta": {"content": "system "}, "finish_reason": null, "index": 0}]}

...

data: [DONE]

```

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

### Ejento AI Assistant Response with Redacted PII

Source: https://context7.com/context7/docshub_ejento_ai/llms.txt

Demonstrates how assistant responses are presented after PII redaction has been applied. It shows a user query and the corresponding assistant response, where sensitive information from the underlying documents is replaced with entity type labels, ensuring PII is not exposed in chat interactions.

```text
# Assistant responses use redacted versions:
# - User query: "What issues did customers report?"
# - Assistant: "Customer {{PERSON}} reported issue with account..."
# - PII never exposed in chat responses
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.