LLM Functions

An Agent is a combination of a Prompt, Tools (Function Calling), and Documents (RAG). Each agent resides in its own directory within the agents/ folder and follows this structure:

└── agents
    └── myagent
        ├── functions.json                  # JSON declarations (Auto-generated)
        ├── index.yaml                      # Agent definition
        ├── tools.txt                       # Shared tools
        └── tools.{sh,js,py}                # Agent-specific tools

The index.yaml file defines the agent's behavior. Key fields include:

• name: The agent's name.
• description: A description of the agent.
• version: The version string.
• instructions: The system prompt/instructions for the LLM.
• conversation_starters: A list of suggested user prompts.
• variables: Custom variables available to the agent.
• documents: A list of local files, directories, or remote URLs for RAG.

name: TestAgent                             
description: This is test agent
version: 0.1.0
instructions: You are a test ai agent to ... 
conversation_starters:
  - What can you do?
variables:
  - name: foo
    description: This is a foo
documents:
  - local-file.txt
  - local-dir/
  - https://example.com/remote-file.txt

To allow external Model Context Protocol (MCP) tools to be used by LLM-Functions, create a mcp.json file in your <llm-functions-dir>. This file defines the MCP servers that the bridge will launch and register.

Each server entry in mcpServers can include:

• command: The executable to run.
• args: An array of arguments for the command.
• env: An object containing environment variables required by the server.
• prefix: A boolean (defaulting to true) that determines if tool names should be automatically prefixed with the server name (e.g., sqlite_query). Set this to false to use the raw tool names and avoid clashes manually.

{
  "mcpServers": {
    "sqlite": {
      "command": "uvx",
      "args": [
        "mcp-server-sqlite",
        "--db-path",
        "/tmp/foo.db"
      ]
    },
    "git": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository",
        "path/to/git/repo"
      ],
      "prefix": false
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"
      }
    }
  }
}

In JavaScript, use JSDoc-style comments to define the tool's parameters. The @typedef block defines an Args object where each @property represents a parameter.

• /** ... */: The comment block containing the tool description and parameter definitions.
• @typedef {Object} Args: Defines the type of the argument object.
• @property {<type>} <name> <description>: Defines a parameter.
  • <type>: Data type (e.g., string, boolean, number, string[], or {foo|bar} for enums).
  • <name>: The parameter name.
  • <description>: Description of the parameter.
  • []: Append brackets to the name (e.g., [name]) to indicate an optional parameter.

You can export the tool using exports.run = function (args) { ... } or via ESM export function run() { ... }.

/**
 * Demonstrate how to create a tool using Javascript and how to use comments.
 * @typedef {Object} Args
 * @property {string} string - Define a required string property
 * @property {'foo'|'bar'} string_enum - Define a required string property with enum
 * @property {string} [string_optional] - Define a optional string property
 * @property {boolean} boolean - Define a required boolean property
 * @property {Integer} integer - Define a required integer property
 * @property {number} number - Define a required number property
 * @property {string[]} array - Define a required string array property
 * @property {string[]} [array_optional] - Define a optional string array property
 * @param {Args} args
 */
exports.run = function (args) {
  // ... your JavaScript code ...
}

In Python, use standard type hints in the function signature and provide parameter descriptions in the function's docstring.

• Type Hints: Use standard types like str, bool, int, float, List[str], or Literal["foo", "bar"] for enums.
• Optional Parameters: Use Optional[...] from the typing module.
• Docstrings: Use the Args: section in the docstring to provide descriptions for each parameter.

Example structure:

def run(param: type, optional_param: Optional[type] = None):
    """
    Description.
    Args:
        param: Description of param
    """

def run(
    string: str,
    string_enum: Literal["foo", "bar"],
    boolean: bool,
    integer: int,
    number: float,
    array: List[str],
    string_optional: Optional[str] = None,
    array_optional: Optional[List[str]] = None,
):
    """Demonstrate how to create a tool using Python and how to use comments.
    Args:
        string: Define a required string property
        string_enum: Define a required string property with enum
        boolean: Define a required boolean property
        integer: Define a required integer property
        number: Define a required number property
        array: Define a required string array property
        string_optional: Define a optional string property
        array_optional: Define a optional string array property
    """
    # ... your Python code ...