Skip to content

Skills Overview

Skills are the extensibility system in Forra that allows you to add custom functionality to your AI assistants. A Skill is reusable logic that can be private to a single assistant or shared across multiple assistants.

What are Skills?

Skills enable you to extend Forra assistants beyond their built-in capabilities by:

  • Adding custom business logic - Integrate with your internal systems, databases, or APIs
  • Performing specialized computations - Create domain-specific calculations or data processing
  • Accessing external services - Connect to third-party platforms and tools
  • Building reusable functionality - Write once, use across multiple assistants

Skill Scopes

Skills can be scoped at different levels to control their availability and lifecycle:

Global Skills

Global Skills are managed at the tenant level and can be shared across multiple assistants.

Learn more about Global Skills →

Assistant Skills

Assistant Skills are owned by a specific assistant and only available to that assistant.

Learn more about Assistant Skills →

Comparison

Aspect Global Skills Assistant Skills
Scope Tenant-wide Single assistant
Who manages Admins/tenant managers Assistant owners
Reusability Can be added to multiple assistants Only available to one assistant
Lifecycle Independent Tied to assistant lifecycle

Skill Types

Skills can be implemented using different technologies. Currently, Functions is the primary implementation type available.

Functions

Functions are Python-based skills that you write using the Forra SDK decorators:

  • @forra.function - Synchronous functions
  • @forra.async_function - Asynchronous functions
  • @forra.webhook - Webhook endpoints for external integrations

Functions are automatically discovered by the LLM and can be called during conversations based on user intent.

Get started with Functions →

What is a @forra.function?

A @forra.function is an ordinary Python function turned into a tool your assistant can call. You write a normal function, decorate it with @forra.function, describe what it does, and annotate each parameter with a Pydantic Field description. Forra uses that metadata to expose the function to the LLM, which decides when to call it during a conversation.

from pydantic import Field
from forrasdk import forra

@forra.function(description="Calculate compound interest")
def calculate_interest(
    principal: float = Field(description="Amount to be invested"),
    rate: float = Field(description="Interest rate"),
    time: int = Field(description="Number of years invested"),
):
    return principal * (1 + rate) ** time

The description on the decorator and on each Field is what the LLM reads to understand the tool — write them as if explaining the function to a teammate. The body runs as plain Python, so it can call APIs, query databases, or perform any computation, and its return value is handed back to the assistant.

See Function Types for @forra.async_function and @forra.webhook.

Future Types

Additional skill types (such as Model Context Protocol integrations) are planned for future releases.

You don't need a separate Skill

A "Skill" is mostly a way to package and share functions. If your functions are only used by one assistant, you don't have to create a standalone Global Skill — you can bundle your @forra.function files directly into the assistant with the Forra CLI. Functions deployed this way are called Assistant Skills and live and die with the assistant.

1. Scaffold an assistant project:

forracli assistants init -d my_assistant
cd my_assistant

2. Drop your @forra.function files into the functions/ directory and point package_info at it in assistants.json:

{
  "assistants": [
    {
      "name": "My Assistant",
      "instructions_text": "You are a helpful assistant.",
      "allowed_functions": ["all"],
      "package_info": {
        "package_path": "functions",
        "package_file_name": "assistant_functions.zip"
      }
    }
  ]
}

3. Deploy the assistant — its functions are packaged and deployed with it:

forracli assistants synchronize -f assistants.json

Reach for a Global Skill only when you want to share the same functions across multiple assistants. Otherwise, bundling functions directly into the assistant is the simplest path.

Create an assistant with functions →

Quick Start

Ready to get started? Choose your path:

Additional Resources