> For the complete documentation index, see [llms.txt](https://docs.labs.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.labs.ai/architecture-and-concepts/extensions.md).

# Extensions

## Overview

**Extensions** are the building blocks of EDDI agents. In EDDI's composable architecture, agents are not monolithic applications but rather **assemblies of extensions**, each providing a specific capability. Extensions are referenced by workflows, and workflows are combined to form complete agents.

### The Agent Composition Hierarchy

```
Agent (.agent.json)
  └─ Workflow 1 (.workflow.json)
      ├─ Extension 1: Behavior Rules (eddi://ai.labs.behavior)
      ├─ Extension 2: HTTP Calls (eddi://ai.labs.httpcalls)
      └─ Extension 3: Output Sets (eddi://ai.labs.output)
  └─ Workflow 2 (.workflow.json)
      ├─ Extension 1: Parser (eddi://ai.labs.parser), using a regular dictionary
      │   (eddi://ai.labs.parser.dictionaries.regular) as a parser sub-extension
      └─ Extension 2: LLM (eddi://ai.labs.llm)
```

> `ai.labs.rules` and `ai.labs.apicalls` are registered aliases of `ai.labs.behavior` and `ai.labs.httpcalls`, and `ai.labs.langchain` of `ai.labs.llm`; both spellings work, and the extension store returns the canonical IDs.

### What Extensions Do

Each extension type corresponds to a **lifecycle task** or **resource** that the agent can use:

| Extension Type                  | Purpose                          | Lifecycle Role                                                                                                                                          |
| ------------------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ai.labs.parser`                | Input parsing and normalization  | Transforms raw user input into structured expressions                                                                                                   |
| `ai.labs.parser.dictionaries.*` | Define vocabularies and entities | Used by parser to recognize intents and entities                                                                                                        |
| `ai.labs.behavior`              | Define IF-THEN rules             | Decides what actions to take based on conditions                                                                                                        |
| `ai.labs.httpcalls`             | Configure external API calls     | Executes HTTP requests to external services                                                                                                             |
| `ai.labs.mcpcalls`              | Call tools on an MCP server      | Invokes MCP tools on behavior-rule actions, and offers them to the LLM — see [MCP Client](https://docs.labs.ai/protocols-and-integration/mcp-client.md) |
| `ai.labs.rag`                   | Retrieval-augmented generation   | Retrieves knowledge-base chunks for the LLM — see [RAG](https://docs.labs.ai/agent-configuration/rag.md)                                                |
| `ai.labs.llm`                   | Configure LLM integrations       | Sends requests to LLM APIs (OpenAI, Claude, etc.)                                                                                                       |
| `ai.labs.output`                | Define output templates          | Formats responses using conversation data                                                                                                               |
| `ai.labs.templating`            | Render output templates          | Renders the `{...}` placeholders of the output; place it last                                                                                           |
| `ai.labs.property`              | Extract and store data           | Manages conversation memory properties                                                                                                                  |

### EDDI Resource URIs

All EDDI's resources start with `eddi://`, which is used to distinguish EDDI-specific extensions from other resources. This URI scheme allows:

* **Version control**: Each extension can have multiple versions
* **Reusability**: The same extension can be used by multiple workflows/agents
* **Clear references**: Explicit URIs make configuration transparent

Example URI:

```
eddi://ai.labs.rules/rulestore/rulesets/673abc123?version=1
```

## Extension Discovery

In this article we will talk about **EDDI**'s **`extensions`**.

**EDDI's `extensions`** are the features that your current instance of EDDI is supporting, the latter are used in the process of configuring/developing an Agent.

The list of `extensions` will allow you to have an overview of what is enabled in your current instance of **EDDI**, the list can be retrieved by calling the API endpoint below.

### Extensions REST API Endpoint

| Element      | Value                        |
| ------------ | ---------------------------- |
| HTTP Method  | `GET`                        |
| API Endpoint | `/extensionstore/extensions` |

## Model

```javascript
[
  {
    type: "string",
    displayName: "string",
    configs: {},
    extensions: {},
  },
];
```

### Description of the model

| Element     | Value                                     |
| ----------- | ----------------------------------------- |
| type        | (`String`) The type of the extension      |
| displayName | (`String`) A given name to the extension  |
| configs     | (`Object`) Configuration of the extension |
| extensions  | (`Object`) Extensions of the extension    |

## Example

> More about regular dictionaries: [Create a dictionary](https://docs.labs.ai/getting-started/creating-your-first-agent.md#6-create-a-dictionary).

The response below is abridged: every registered step type is listed with its config fields, including `eddi://ai.labs.llm`, `eddi://ai.labs.mcpcalls` and `eddi://ai.labs.rag`, which are shown with their `uri` only.

*Request URL*

`GET http://localhost:7070/extensionstore/extensions`

*Response Body*

```javascript
[
  {
    type: "eddi://ai.labs.parser",
    displayName: "Input Parser",
    configs: {
      uri: {
        displayName: "Resource URI",
        fieldType: "URI",
        isOptional: true,
      },
      includeUnknown: {
        displayName: "Include Unknown Expressions",
        fieldType: "BOOLEAN",
        defaultValue: true,
        isOptional: true,
      },
      includeUnused: {
        displayName: "Include Unused Expressions",
        fieldType: "BOOLEAN",
        defaultValue: true,
        isOptional: true,
      },
      appendExpressions: {
        displayName: "Append Expressions",
        fieldType: "BOOLEAN",
        defaultValue: true,
        isOptional: true,
      },
      maxInputTokens: { displayName: "Max Input Tokens", fieldType: "INT", defaultValue: 200, isOptional: true },
      maxSuggestions: { displayName: "Max Suggestions Evaluated", fieldType: "INT", defaultValue: 1000, isOptional: true },
      maxSolutions: { displayName: "Max Solutions Collected", fieldType: "INT", defaultValue: 100, isOptional: true },
    },
    extensions: {
      corrections: [
        {
          type: "eddi://ai.labs.parser.corrections.levenshtein",
          displayName: "Damerau Levenshtein Correction",
          configs: {
            distance: {
              displayName: "Distance",
              fieldType: "INT",
              defaultValue: 2,
              isOptional: true,
            },
            maxCandidates: {
              displayName: "Max Correction Candidates",
              fieldType: "INT",
              defaultValue: 5,
              isOptional: true,
            },
          },
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.corrections.phonetic",
          displayName: "Phonetic Matching Correction",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.corrections.mergedTerms",
          displayName: "Merged Terms Correction",
          configs: {},
          extensions: {},
        },
      ],
      normalizer: [
        {
          type: "eddi://ai.labs.parser.normalizers.punctuation",
          displayName: "Punctuation Normalizer",
          configs: {
            removePunctuation: {
              displayName: "Remove Punctuation",
              fieldType: "BOOLEAN",
              defaultValue: false,
              isOptional: true,
            },
            punctuationRegexPattern: {
              displayName: "Punctuation RegEx Pattern",
              fieldType: "STRING",
              defaultValue: "!?:.,;",
              isOptional: true,
            },
          },
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.normalizers.specialCharacter",
          displayName: "Convert Special Character Normalizer",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.normalizers.contractedWords",
          displayName: "Contracted Word Normalizer",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.normalizers.allowedCharacter",
          displayName: "Remove Undefined Character Normalizer",
          configs: {},
          extensions: {},
        },
      ],
      dictionaries: [
        {
          type: "eddi://ai.labs.parser.dictionaries.integer",
          displayName: "Integer Dictionary",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.dictionaries.decimal",
          displayName: "Decimal Dictionary",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.dictionaries.ordinalNumber",
          displayName: "Ordinal Numbers Dictionary",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.dictionaries.punctuation",
          displayName: "Punctuation Dictionary",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.dictionaries.time",
          displayName: "Time Expression Dictionary",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.dictionaries.email",
          displayName: "Email Dictionary",
          configs: {},
          extensions: {},
        },
        {
          type: "eddi://ai.labs.parser.dictionaries.regular",
          displayName: "Regular Dictionary",
          configs: {
            uri: {
              displayName: "Resource URI",
              fieldType: "URI",
              isOptional: false,
            },
          },
          extensions: {},
        },
      ],
    },
  },
  {
    type: "eddi://ai.labs.behavior",
    displayName: "Behavior Rules",
    configs: {
      appendActions: {
        displayName: "Append Actions",
        fieldType: "BOOLEAN",
        defaultValue: true,
        isOptional: true,
      },
      expressionsAsActions: {
        displayName: "Expressions as Actions",
        fieldType: "BOOLEAN",
        defaultValue: false,
        isOptional: true,
      },
      uri: {
        displayName: "Resource URI",
        fieldType: "URI",
        isOptional: false,
      },
    },
    extensions: {},
  },
  {
    type: "eddi://ai.labs.output",
    displayName: "Output Generation",
    configs: {
      uri: {
        displayName: "Resource URI",
        fieldType: "URI",
        isOptional: false,
      },
    },
    extensions: {},
  },
  {
    type: "eddi://ai.labs.templating",
    displayName: "Templating",
    configs: {},
    extensions: {},
  },
  {
    type: "eddi://ai.labs.property",
    displayName: "Property Extraction",
    configs: {},
    extensions: {},
  },
  {
    type: "eddi://ai.labs.httpcalls",
    displayName: "Http Calls",
    configs: {
      uri: {
        displayName: "Resource URI",
        fieldType: "URI",
        isOptional: false,
      },
    },
    extensions: {},
  },
  {
    type: "eddi://ai.labs.mcpcalls",
    displayName: "MCP Calls",
    configs: {
      uri: { displayName: "Resource URI", fieldType: "URI", isOptional: false },
    },
    extensions: {},
  },
  {
    type: "eddi://ai.labs.rag",
    displayName: "Knowledge Base (RAG)",
    configs: {
      uri: { displayName: "Knowledge Base URI", fieldType: "URI", isOptional: false },
    },
    extensions: {},
  },
  {
    type: "eddi://ai.labs.llm",
    displayName: "Lang Chain",
    configs: {
      uri: { displayName: "Resource URI", fieldType: "URI", isOptional: false },
    },
    extensions: {},
  },
];
```

*Response Code*

`200`
