No Code–Tool Calling on the Prem Platform

Modern AI systems can do more than just respond to user queries; they can also take action. This is the critical step that transforms a traditional chatbot into a genuine AI assistant—one capable of sending messages, scheduling events, updating data, and more. Yet building such capabilities often requires extensive programming, complex authentication flows, and intricate JSON schema definitions for function calling.

Prem’s No Code–Tool Calling streamlines this entire process. By integrating with popular services (like Slack, Google Calendar, GitHub, Notion, and more) under one cohesive platform, you can focus on shaping your AI’s objectives rather than coding bespoke integrations. In this article, we will explain how this feature works, illustrate its synergy with other modules in the Prem Platform, and share a detailed scenario to demonstrate its benefits in a real-world setting.

Why No Code–Tool Calling?

Beyond Basic Conversation

While large language models excel at interpreting prompts and generating text, the true utility of AI emerges when it can perform concrete actions. This might involve:

• Scheduling a meeting in your Google Calendar.
• Posting a message to a Slack channel.
• Opening a GitHub issue.
• Retrieving updated information from a Notion database.

Equipping an LLM with these capabilities makes it a full-fledged AI agent. However, achieving this typically demands a significant amount of time and code. No Code–Tool Calling removes that complexity, enabling you to add essential integrations with minimal effort.

Strengthening the Prem Ecosystem

The Prem Platform is composed of multiple modules—Projects, Lab, Monitoring & Tracing, Launchpad, Repositories, Autonomous Fine-Tuning, and more. No Code–Tool Calling augments each of these:

• Lab: Experiment with different models and function calls in real-time.
• Projects: Tie integrations directly to your AI solution for easy access and project-specific authentication.
• Monitoring & Tracing: Capture every integration request to ensure transparency, debug errors, and optimize performance.
• Launchpad: Package a fully integrated model (complete with tool-calling capabilities) for production deployment.
• Repositories (RAG): Combine tool calls with knowledge retrieval from your private documents.
• Autonomous Fine-Tuning: Use the data and logs generated from these integrations to refine your model further.

By connecting all these modules, you can design AI solutions that not only understand your data but also act on it.

Under the Hood: Architecture

Leveraging Composio

Composio sits at the heart of our integrations layer, taking care of the most intricate aspects of third-party API interactions. It manages OAuth2 authentication, token refresh, and uniform input/output mappings for dozens of popular services. Within the Prem Platform:

1. OAuth Flows

• When you initiate a new Connection (e.g., for Slack), Prem calls Composio’s API to generate an OAuth2 authorization URL for that specific integration and organization.
• Once the user authorizes this request on the third-party service’s side (e.g., Slack’s OAuth page), Composio automatically exchanges the authorization code for an access token (and refresh token, if applicable).
• Composio then pings our integration_webhook, providing us with the final OAuth credentials. These details are securely stored by Prem in its own database (encrypted at rest).

2. Token Refresh

• For integrations that require continuous reauthorization (e.g., Slack, Google Calendar), Composio periodically handles refresh tokens behind the scenes. This means you do not have to manually re-authenticate your integrations or store custom logic for token renewal in your application code.

3. Service-Specific Requirements

• Different services may require custom scopes, domain whitelists, or advanced rate-limiting. Composio abstracts these complexities with standardized endpoints and reuses best practices across multiple integrations.

4. Scalability and Organization Management

• Each organization in Prem maps to an Entity in Composio. That Entity can have multiple Connections to different integrations (or even multiple Connections to the same integration, e.g., multiple Slack workspaces). Composio keeps these relationships in sync.

5. Room for Customization

• While Composio simplifies the majority of our integrations, the Prem architecture does not lock you into it. If you decide to replace Composio or write your own connectors later, you can do so by plugging into the same data model (Integration, Connection, etc.) without forcing a major rewrite of your AI workflows.

Overall, Composio frees the Prem Platform from implementing each service’s OAuth flow and token lifecycle repeatedly. Instead, we can focus on providing a seamless user experience for integration setup while retaining the flexibility to manage or replace back-end services as needed.

Key Components and Data Structures

Within Prem’s data model, four core tables—Integration, IntegrationAction, Connection, and ConnectionAction—encapsulate how third-party services are defined, connected, and ultimately utilized by projects.

Integration

• Purpose: Represents a top-level external service, such as Slack or GitHub.
• Data Fields: Typically includes name, slug, description, and a logo URL. The slug here matches the corresponding Composio integration identifier (e.g., "SLACKBOT" for Slack), so we can map each internal Integration object to the correct third-party connector.
• Creation: New Integrations are typically defined in integrations.json and loaded via load_integrations.py. Once loaded, they become selectable in the Prem UI for all organizations.

IntegrationAction

• Purpose: Defines a specific capability within an Integration—e.g., “Send Slack Message,” “Create GitHub Issue.”
• Data Fields: Includes name, description, and a slug that also aligns with Composio’s definition of that particular action.
• Usage: These actions become the blueprint for function calls. For instance, if an LLM says, “I want to send a Slack message,” the system knows to look up the Slack “Send Message” action’s schema.

• Connection

Purpose: Links a particular organization in Prem to a specific Integration, storing references to the credential data.

• Data Fields:

• organization_id: Identifies which org the Connection belongs to.
• integration_id: Links to a row in Integration (e.g., Slack).
• credentials_id: Points to the credentials record (encrypted tokens).
• status: Indicates if the connection is active, revoked, or in progress.

• Workflow: During creation, we call Composio to begin the OAuth handshake. After successful authorization, Composio notifies us so we can mark the Connection as active.

• ConnectionAction

1. Purpose: Represents a “deployed” action within a project, referencing both the Connection and the specific IntegrationAction to be used.

• Data Fields:

• connection_id: Points to the Connection object, meaning “which Slack workspace” or “which GitHub account.”
• integration_action_id: Points to the “Send Slack Message” or “Create GitHub Issue” action.
• project_id: Indicates which project uses this action.
• Additional configuration or metadata (e.g., default channel to post to, if the action supports it).

• Significance: This is what your AI actually calls at runtime. If a user’s prompt triggers “Send Slack Message,” the system checks the relevant ConnectionAction to confirm which Slack workspace is available and how to reach Composio’s Slack connector.

Putting It All Together

• A user in an organization chooses to “add Slack.” Internally, we create a Connection referencing the Slack Integration and store OAuth credentials from Composio.
• Then they want the ability to “Send Slack Message,” so we set up a ConnectionAction linking that Slack Connection to the “Send Slack Message” action.
• Whenever a project’s LLM wants to post in Slack, the AI produces a function call referencing that ConnectionAction. Prem routes the request to Composio, which in turn performs the underlying Slack API call.
• Trace logs capture the entire process, ensuring transparent, debuggable tool usage.

This design guarantees minimal duplication of logic across different integrations (Slack, GitHub, Google Calendar, etc.). Instead, all services follow the same consistent data model and flow, making it easier to add new integrations or maintain existing ones over time.

A Detailed Workflow: The “Weekly Launch Announcement” Scenario

To illustrate why No Code–Tool Calling is so advantageous, let us consider a realistic scenario:

The Objective

Alice aims to build an “AI Launch Assistant” that does two key tasks:

1. Fetch product updates from a Notion repository.
2. Post a status message each Friday on Slack’s #announcements channel.

She wants this to happen automatically, without manually copying information each week.

Setting Up the Project

1. Create Project: In the Prem interface, Alice creates a new Project named “Launch Assistant.”
2. Add a Repository: She uses Repositories (RAG) to store or connect her Notion docs that detail product changes. This ensures the AI can quickly reference relevant text.

Integrating Slack

1. Choose Slack in the Prem Integrations list.
2. Initiate OAuth: Composio handles the Slack permission handshake. Alice simply authorizes the integration when prompted.
3. Connection Creation: Once authorized, a Slack Connection is established in the Prem system.
4. ConnectionAction: Alice assigns the “Send Slack Message” action to this Connection, effectively enabling the Project to issue Slack posts.

Testing and Fine-Tuning in the Lab

1. Open a Lab Playground: Alice experiments with prompts like, “Each Friday, summarize the product changes from Notion and post them in #announcements on Slack.”
2. Verify Tool Calls: She checks the Lab to ensure the AI is calling the correct action, passing the appropriate Slack channel and message text.
3. Refine Outputs: If the summary appears too long or too short, she adjusts system prompts and tries again.

Observing in Monitoring & Tracing

While testing, Alice reviews the Monitoring & Tracing module to see:

• How often the AI calls Slack.
• What arguments the AI includes in each request.
• Whether any errors occur (like channel_not_found).

This data not only validates the system’s correctness but also informs ongoing improvements.

Launching and Automating

Satisfied with her testing, Alice heads to the Launchpad:

1. Select the model and attach the repository for context.
2. Include the Slack action in the final deployment.
3. Launch the “AI Launch Assistant.”

Henceforth, her newly launched model—now integrated with Slack—requires no further manual action from her or the development team. The “AI Launch Assistant” handles the entire weekly update workflow.

How It Interacts with Other Prem Modules

1. Projects

• Maintains clear boundaries. Alice’s Slack integration belongs specifically to the “Launch Assistant” Project, helping her track usage, isolate access, and manage membership.

2. Lab

• Provides a safe experimentation environment to iterate on prompts, function calls, or system configurations.

3. Monitoring & Tracing

• Offers visibility into each action call. Alice can quickly audit suspicious activity (like a Slack post going to the wrong channel) and verify that the correct content was sent.

4. Repositories

• Connects relevant documents (e.g., product updates in Notion) directly to the AI. By retrieving context from Notion, the AI’s Slack messages include accurate and current information.

5. Launchpad

• Harmonizes final deployment settings—including the model, integration actions, system prompts, and repository references—into a single, ready-to-use solution.

6. Autonomous Fine-Tuning

• Collects usage logs to refine the model’s performance. If the AI often struggles to parse specific data from the product update text, these interactions can be used to train a more specialized or less error-prone model.

Adding a New Integration: Technical Steps

This section details how to introduce a new integration into the Prem Platform, test it, and then use it from the AI’s perspective (i.e., function calls triggered by an LLM). By following these steps, you can quickly enable your AI to interact with external services—like Slack, GitHub, Google Calendar, or any other system supported by Composio (or custom connectors in the future).

Defining the Integration in integrations.json

• Add the Integration ObjectExample (Slack):

{
  "name": "Slack",
  "slug": "SLACKBOT",
  "logo": "https://raw.githubusercontent.com/SamparkAI/open-logos/d9b539471e551d6c14ffd442d172e476edd44b33/slack.svg",
  "description": "Slack is a cloud-based team collaboration tool that allows you to communicate with your team using messages, files, and voice calls.",
  "actions": [
    {
      "name": "Send Message to Slack Channel",
      "description": "Send a message to a Slack channel",
      "slug": "SLACKBOT_SENDS_A_MESSAGE_TO_A_SLACK_CHANNEL"
    }
  ]
}

• Open integrations.json and create a new block describing the external service you wish to integrate. A typical integration definition includes:

• A name (e.g., “Slack”).
• A slug corresponding to Composio’s identifier (e.g., "SLACKBOT").
• A logo URL (optional but useful for UI purposes).
• A description that explains what the service is or does.
• An actions array describing each possible tool action the AI could call.

• Run load_integrations.py

• Execute this script to read your new JSON block(s) and insert or update the corresponding Integration and IntegrationAction records in the Prem database.
• After this step, Prem “knows” about the new integration and any associated actions, making them selectable in the UI or API.

Setting Up Credentials

New integrations often demand OAuth client IDs, secrets, or API tokens. Prem handles this via a Credentials model that maps to the stored tokens.

• Add Credential Logic

In credentials.py (and related utilities), define or update methods such as:

• get_credentials_model(): Returns the Credential model class.
• create_credentials(): Creates a new credential record in the DB.
• get_default_credentials_config(): Fetches default client IDs or secrets (e.g., from environment variables).
• get_auth_config(): Retrieves any relevant OAuth scopes and endpoints for the integration.

• Add Default Credential IDs

• Update your .env and .env.example to include environment variables (e.g., SLACK_CLIENT_ID, SLACK_CLIENT_SECRET) if you plan to store a default credential for all organizations to share.
• Use custom credentials (per organization) if each org needs its own OAuth client or specialized setup.

Initiating and Testing the Connection

Once the integration is known to Prem and credentials have been defined, you can create a Connection that links a particular organization to the new service.

• Create Connection (UI or API)

• An organization admin (or script) triggers the connection creation process. For instance, “Connect Slack.”
• Prem calls Composio to request an OAuth2 URL.
• The user clicks the link, authorizes the service (Slack), and Composio calls back Prem’s integration_webhook to confirm success.
• In the Prem database, a Connection record is activated upon success, referencing the newly created Credentials entry.

• Assign an Action to a Project

• Within that same organization, you create a ConnectionAction by selecting both the newly activated Connection (i.e., Slack workspace) and one of the IntegrationActions (e.g., “Send Slack Message”).
• Finally, you attach this ConnectionAction to the desired project, indicating “this project can now call the Slack ‘Send Message’ action.”

• End-to-End Validation

• You can Test in the Lab or call the Prem API to ensure your LLM can successfully invoke “Send Slack Message” (or your chosen action).
• For thorough testing, create another connection with custom credentials (perhaps pointing to a different Slack workspace) and validate that both connections function as intended for different projects or orgs.

Calling an Integration Action Via the Prem API

Once a project has at least one ConnectionAction deployed, any AI conversation that triggers a function call can leverage that tool. Here’s the high-level flow in the Prem backend:

1. User Sends Prompt

• The user or client application calls handle_chat_completion (or a relevant endpoint in the Prem API) with a conversation message.

2. LLM Response & Tool Call

• The LLM returns a response in JSON, indicating a tool_call (i.e., it wants to invoke “SLACKBOT_SENDS_A_MESSAGE_TO_A_SLACK_CHANNEL”, passing necessary parameters like channel and message_text).

3. Dispatch to Composio

• Prem checks if the project has a matching ConnectionAction (Slack → “Send Slack Message”). If so, it forwards the call, along with the correct OAuth tokens or credentials, to Composio.

4. External Service Execution

• Composio performs the Slack API call (or whichever integration is in use).

5. Confirmation and UI Output

• Once Composio confirms success, Prem’s generate_message_from_tool_calls method composes a final message (e.g., “I sent the message to #general”) to show the end user.

During this process, Monitoring & Tracing logs every tool call so you can audit any issues or analyze usage patterns.

Deploying the Project

After verifying that your new integration works in a test environment:

1. Launch via the Launchpad

• Choose the final model, attach your repository (if using RAG), and confirm your chosen ConnectionActions.
• The Launchpad bundles these configurations into a production-ready deployment.

2. Integrate with Your Application

• Using the Prem SDK or REST API, your app can now interact with the newly integrated AI, triggering tool calls as needed.

3. Monitor & Refine

• Continue to monitor the logs for real usage, track any errors, and refine prompts or credentials as your solution grows.

Conclusion

No Code–Tool Calling revolutionizes how you incorporate AI into your workflows. By freeing you from the burden of custom API wrappers, OAuth flows, and function-calling schema definitions, it enables you to build fully interactive AI agents faster and with less complexity. Moreover, because this feature integrates so seamlessly with every other facet of the Prem Platform—Projects, Lab, Monitoring & Tracing, Launchpad, Repositories, and Autonomous Fine-Tuning—the end result is a cohesive, highly capable AI solution.

Whether you aim to automate recurring tasks, collaborate across multiple APIs, or enrich your LLM with real-time data, the capabilities unlocked by No Code–Tool Calling empower you to move from mere “chatbots” to genuine, task-oriented AI agents. As you continue to develop and refine your solutions, rest assured that the Prem Platform has all the tools you need to iterate swiftly, monitor effectively, and deploy at scale—turning your vision of interactive AI into a reality.

Ready to get started? Check out our Quickstart Guide to spin up your first project, then head over to the Autonomous Fine-Tuning or Repositories sections for more advanced techniques. With No Code–Tool Calling, your AI can truly do it all—no extra coding required.