Connect Docebo to AI Agents: Orchestrate Skills and Certifications
Give your AI agent Docebo tools.
Connect Docebo to AI agents using Truto's /tools endpoint. This guide covers bypassing Docebo's API quirks, framework-agnostic tool binding, and building robust LLM agent loops.
In this guide
- 01Configure Docebo Tools
- 02Fetch Proxy API Tools
- 03Bind Tools to your Agent
- 04Implement the Agent Loop
The guide
Learn how to connect Docebo to AI agents using Truto's /tools endpoint. Build autonomous LMS workflows for skills tracking, course enrollment, and compliance ops.
You want to connect Docebo to an AI agent so your system can independently map employee skills, manage course enrollments, track certifications, and oversee compliance across your entire organization. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to build and maintain a custom Docebo integration from scratch.
Giving a Large Language Model (LLM) read and write access to your Docebo LMS instance is an engineering headache. You either spend weeks building, hosting, and maintaining a custom connector, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on connecting Docebo to ChatGPT, or if you are building on Anthropic's models, read our guide on connecting Docebo to Claude. For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework.
This guide breaks down exactly how to fetch AI-ready tools for Docebo, bind them natively to an LLM using frameworks like LangChain, LangGraph, CrewAI, or the Vercel AI SDK, and execute complex learning and development workflows. For a deeper look at the architecture behind this approach, refer to our research on architecting AI agents and the SaaS integration bottleneck.
Why a Unified Tool Layer Matters for Agent Safety
Before writing a line of integration code, decide what layer your agent talks to. This choice determines how safe and deterministic your production system will be.
Direct API tools (one custom-coded tool per raw Docebo endpoint) look convenient, but they push provider quirks directly into the LLM's context window. The model has to remember intricate details about Docebo's service-oriented architecture, how to properly format nested JSON search operators, and when to pass a user_id versus an id_user. Every one of those quirks is a hallucination waiting to happen.
A centralized tool layer collapses these complexities behind a consistent schema. Your agent sees create_a_docebo_enrollment, list_all_docebo_certification, and docebo_skill_profile_get_profile. That gives you four concrete safety wins:
- Smaller attack surface for hallucination. The LLM only ever chooses from a stable list of rigidly defined functions. It never invents query parameter structures.
- Deterministic input validation. Every tool has a strict JSON schema. Invalid arguments are rejected by Truto's proxy layer before they hit Docebo, meaning a broken tool call fails fast.
- Isolated authentication. Your agent never touches Docebo API keys or OAuth tokens. It authenticates with Truto, which handles the secure token lifecycle downstream.
- Real-time tool documentation. Tool descriptions update automatically based on your integration configuration, ensuring the LLM always has the correct semantic context for when to use a specific function.
The Engineering Reality of the Docebo API
Giving an LLM access to external data sounds simple during local prototyping. You write a Node.js function that makes a fetch request and wrap it in an @tool decorator. In production against complex enterprise systems like Docebo, this approach quickly collapses.
Docebo's API introduces several specific integration challenges that break standard REST assumptions. If you hardcode these interactions into your agent, you will spend your sprints writing defensive API wrapping code instead of improving your model's reasoning.
The Microservice Fragmentation Trap
Docebo does not have a single, unified API surface. It operates across multiple distinct services, each with its own base path and logic. To manage courses and enrollments, you hit the /learn service. To manage skills and manager overviews, you hit the /skill service. For file assets and sharing, it is the /share service, and for users and organizational charts, it is the /manage service.
If you build this manually, your LLM needs to know which base URL applies to which entity. Truto abstracts this fragmentation. The agent simply calls docebo_skill_profile_get_profile, and the infrastructure routes it to /skill/v1/profile/{id_user} behind the scenes.
Complex Search and Filter Arrays
Standard APIs allow simple query parameters like ?title=Sales. Docebo often requires complex, stringified JSON arrays for filtering. For example, to search for a certification, the raw API expects a payload structure resembling [{"title":{"option":"contains","value":"search string goes here"}}].
Standard LLMs are notoriously bad at generating nested, escaped JSON within query parameters on the fly. By exposing a flattened, documented schema through Truto's /tools endpoint, the LLM provides standard key-value arguments, and the translation layer handles the idiosyncratic formatting required by Docebo.
Inconsistent Identifier Naming Conventions
Throughout the Docebo API, the naming conventions for foreign keys fluctuate. A user ID might be user_id, id_user, or simply id depending on the specific endpoint and service. Course IDs experience similar variations (course_id vs id_course). This semantic ambiguity confuses LLMs, leading to misaligned arguments and failed requests. Truto's tool generation explicitly maps these requirements into the JSON schema, forcing the LLM to provide the correct identifier for the specific context.
Hero Tools for Docebo Automation
Truto exposes Docebo's extensive API surface as modular tools. Below are the highest-leverage tools for orchestrating skills and learning plans.
list_all_docebo_certification
Retrieves all certifications across the LMS. This is the foundational tool for auditing compliance and understanding what credentials currently exist in the system. The tool accepts optional filter parameters to narrow the search by certification title or status.
"Audit the LMS for all active certifications containing the word 'Compliance' in the title and return their IDs."
create_a_docebo_enrollment
Enrolls one or more users into specific courses. This tool handles the core operational requirement of an LMS agent: actually putting people into training. It requires an array of course_ids and user_ids, along with an enrollment level (e.g., learner).
"Enroll the new engineering hires (User IDs: 1042, 1043) into the 'Cloud Security Fundamentals' course (Course ID: 221) as learners."
docebo_skill_profile_get_profile
Retrieves the associated skills and expertise levels for a specific user. This tool is critical for personalized learning agents that need to understand a user's current baseline before recommending or assigning new training content.
"Fetch the skill profile for user ID 4091 and list their current expertise levels in Python and AWS."
update_a_docebo_skill_profile_by_id
Sets or updates the occupation and associated skills for a user. After an agent evaluates a user's completion of a course or an external assessment, it uses this tool to officially register their new skill level within Docebo.
"Update the skill profile for user ID 4091 to reflect an 'Advanced' expertise level in AWS Architecture."
list_all_docebo_manager_skill_overview
Retrieves a high-level skills overview for a manager's team. This is a powerful aggregation tool that allows an agent to assess the collective capabilities of an entire department, identifying systemic skill gaps without needing to query every individual user.
"Generate a skill overview for my team and identify which required DevOps skills currently have the lowest average expertise level."
create_a_docebo_learningplan
Creates a brand new learning plan. When an agent identifies a recurring skill gap, it can use this tool to programmatically generate a targeted learning plan, complete with a name and description, which it can subsequently populate with courses.
"Create a new learning plan called 'Q3 Sales Enablement' with a description focusing on the new enterprise product line."
For the complete inventory of available Docebo tools, including advanced operations for ILT sessions, gamification, and organizational charts, view the Docebo integration page.
Workflows in Action
Single tool calls are useful, but the real power of an AI agent emerges when chaining multiple Docebo operations together to solve complex business logic. Here is how standard LMS workflows map to agentic execution.
1. Automated Skill Gap Analysis and Enrollment
An engineering manager asks the agent to evaluate a specific engineer's readiness for a new project and assign necessary training.
"Check the skill profile for Jane Doe (ID: 5521). If she does not have 'Advanced' Kubernetes skills, enroll her in the 'Advanced K8s Architecture' course (ID: 301)."
- The agent calls
docebo_skill_profile_get_profilepassingid_user: 5521. - The agent parses the returned JSON, evaluating the user's recorded expertise level for Kubernetes.
- Recognizing a deficiency, the agent calls
create_a_docebo_enrollmentpassinguser_ids: [5521],course_ids: [301], and the appropriate enrollment level. - The agent returns a confirmation to the manager that the skill gap was identified and the enrollment is active.
2. Department-Wide Compliance Enforcement
An HR administrator needs to ensure the entire customer support team is up to date on their data privacy certifications.
"Audit the customer support team (Manager ID: 884). Find anyone who lacks the '2026 GDPR Compliance' certification and enroll them immediately."
- The agent calls
docebo_manager_subordinates_get_subordinates(or a similar org-chart tool) to retrieve the user IDs for the manager's team. - The agent iterates through the team, calling
docebo_award_users_get_userfor each user to check their active certifications. - The agent compiles a list of user IDs missing the required certification.
- The agent executes a bulk action using
create_a_docebo_enrollmentwith the compiled array ofuser_idsand the specific GDPR course ID. - The agent outputs a summary report listing the names of the employees who were just enrolled.
3. Dynamic Learning Plan Generation
A sales director wants a custom onboarding track built for a new cohort of enterprise account executives.
"Create a new learning plan called 'Enterprise AE Bootcamp'. Add the courses 'Negotiation Tactics' (ID: 105) and 'Enterprise Security Specs' (ID: 108) to it."
- The agent calls
create_a_docebo_learningplanpassing the title and description. - Docebo returns the ID of the newly created learning plan.
- The agent extracts that new ID and calls
create_a_docebo_learningplan_course, passing the newlearning_plan_idand the array of course IDs (105,108). - The agent informs the sales director that the bootcamp is ready for enrollment.
sequenceDiagram
participant User as User Prompt
participant Agent as AI Agent (LangGraph)
participant Truto as Truto API
participant Docebo as Docebo LMS
User->>Agent: "Create Enterprise AE Bootcamp<br>and add courses 105, 108"
Agent->>Truto: Call create_a_docebo_learningplan
Truto->>Docebo: POST /learn/v1/lp
Docebo-->>Truto: Return LP ID (e.g., 992)
Truto-->>Agent: Standardized LP details
Agent->>Truto: Call create_a_docebo_learningplan_course
Truto->>Docebo: POST /learn/v1/lp/992/courses
Docebo-->>Truto: 200 OK
Truto-->>Agent: Courses associated
Agent-->>User: "Bootcamp created successfully."Building Multi-Step Workflows
To build these workflows in code, you need an execution environment that supports function calling. The following approach works with any major framework (LangChain, Vercel AI SDK, CrewAI) because Truto's /tools endpoint returns standard JSON schemas.
Here is how you fetch Docebo tools using the Truto SDK and bind them to an agent in a LangChain environment.
Initializing the Tool Manager
First, initialize the Truto tool manager with your Docebo integrated account ID. The SDK will reach out to the /tools endpoint and retrieve all configured methods as executable functions.
import { TrutoToolManager } from 'truto-langchainjs-toolset';
import { ChatOpenAI } from '@langchain/openai';
// Initialize the Truto SDK with your Docebo Integrated Account ID
const toolManager = new TrutoToolManager({
trutoApiKey: process.env.TRUTO_API_KEY,
integratedAccountId: 'YOUR_DOCEBO_ACCOUNT_ID'
});
async function runAgent() {
// Fetch the Docebo tools
const tools = await toolManager.getTools();
// Initialize your LLM and bind the tools to it
const llm = new ChatOpenAI({ modelName: 'gpt-4o' });
const llmWithTools = llm.bindTools(tools);
// ... proceed to agent loop
}Handling Rate Limits and Execution
When an AI agent runs in a loop, it can generate API requests faster than the underlying SaaS provider allows.
A critical factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors automatically. When the upstream Docebo API returns an HTTP 429 (Too Many Requests), Truto passes that error directly to the caller.
However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. It is the responsibility of your agent loop to detect these 429s, read the headers, and pause execution.
Here is a conceptual example of how you handle tool execution and rate limiting gracefully:
import { HumanMessage } from '@langchain/core/messages';
async function executeWorkflow(prompt: string) {
const messages = [new HumanMessage(prompt)];
while (true) {
// Agent decides what to do
const aiMessage = await llmWithTools.invoke(messages);
messages.push(aiMessage);
// If no tool calls, the agent is finished
if (!aiMessage.tool_calls || aiMessage.tool_calls.length === 0) {
console.log("Final Answer:", aiMessage.content);
break;
}
// Execute the required tools
for (const toolCall of aiMessage.tool_calls) {
try {
console.log(`Executing Docebo action: ${toolCall.name}`);
const tool = tools.find(t => t.name === toolCall.name);
const result = await tool.invoke(toolCall.args);
messages.push({ role: 'tool', tool_call_id: toolCall.id, content: result });
} catch (error) {
// Explicitly handle 429 Rate Limits passed through by Truto
if (error.status === 429) {
const resetTime = error.headers['ratelimit-reset'];
console.warn(`Rate limit hit. Pausing agent until ${resetTime}...`);
// Implement your own backoff/delay logic here based on the header
await delayUntil(resetTime);
// Push a system message so the LLM knows to retry the tool
messages.push({
role: 'tool',
tool_call_id: toolCall.id,
content: "Error 429: Rate limit exceeded. Please try again."
});
} else {
// Handle normal API or validation errors
messages.push({
role: 'tool',
tool_call_id: toolCall.id,
content: `Execution failed: ${error.message}`
});
}
}
}
}
}
executeWorkflow("Enroll user ID 5521 in course ID 301.");By injecting the rate limit failure and other errors back into the context window as a tool role message, the LLM is informed of the failure and can gracefully decide to retry the operation or explain the issue to the human operator.
Orchestrating Learning at Scale
Building an AI agent that can reliably operate Docebo requires more than just API keys and prompt engineering. It requires a resilient infrastructure layer that normalizes microservice fragmentation, standardizes nested query logic, and provides strict schemas for LLM execution.
By utilizing Truto's /tools endpoint, you decouple your agent's reasoning capabilities from the volatile reality of enterprise LMS APIs. You stop writing defensive boilerplate and start building autonomous learning operations that can scale across your entire workforce.
FAQ
- How do AI agents handle Docebo's fragmented microservice API architecture?
- Truto collapses Docebo's various endpoints (e.g., /learn, /skill, /manage) into a single, unified tool schema. The LLM only sees deterministic function names like `create_a_docebo_enrollment` and does not need to guess base URLs or authentication routing.
- Can I use Truto's Docebo tools with LangChain or LangGraph?
- Yes. Truto's /tools endpoint is framework-agnostic. Using the TrutoToolManager from our SDK, you can map Docebo endpoints to any agent framework that supports standard function calling, including LangChain, CrewAI, and the Vercel AI SDK.
- How does Truto handle Docebo API rate limits for agents?
- Truto passes HTTP 429 rate limit errors directly to your application without applying automatic backoff or retries. We normalize the upstream rate limit information into standard headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) so your agent loop can safely throttle its own requests.