---
title: "Connect Degreed to ChatGPT: Automate user skills and learning paths"
slug: connect-degreed-to-chatgpt-automate-user-skills-and-learning-paths
date: 2026-10-22
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to connect Degreed to ChatGPT using a managed MCP server. Automate user skills, curate learning paths, and build AI agents for enterprise L&D."
tldr: "Connect Degreed to ChatGPT in minutes using Truto's managed MCP servers. Auto-generate AI tools to automate skill tracking, pathway creation, and enterprise L&D workflows without writing custom API boilerplate."
canonical: https://truto.one/blog/connect-degreed-to-chatgpt-automate-user-skills-and-learning-paths/
---

# Connect Degreed to ChatGPT: Automate user skills and learning paths


If you want to connect Degreed to ChatGPT so your AI agents can curate learning paths, track employee skills, generate custom training programs, and monitor course completions, you need a [Model Context Protocol (MCP) server](https://truto.one/blog/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Degreed's REST APIs. 

If your team uses Claude, check out our guide on [connecting Degreed to Claude](https://truto.one/connect-degreed-to-claude-manage-courses-items-and-certifications/) or explore our broader architectural overview on [connecting Degreed to AI Agents](https://truto.one/connect-degreed-to-ai-agents-sync-learning-data-and-skill-ratings/).

Giving a Large Language Model (LLM) secure, scoped read and write access to an enterprise Learning Management System (LMS) is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom MCP server to translate LLM JSON arguments into Degreed's highly specific entity structures, or you use a [managed infrastructure layer](https://truto.one/blog/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/).

This guide breaks down exactly how to use Truto to generate a secure, authenticated MCP server for Degreed, connect it natively to [ChatGPT](https://truto.one/blog/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/), and execute complex Learning and Development (L&D) workflows using natural language.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Degreed API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Degreed's enterprise API surface is exceptionally painful. 

If you decide to build a custom MCP server for Degreed, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Degreed:

### Polymorphic Content Relationships
Degreed handles dozens of distinct content types - articles, books, videos, courses, podcasts, assessments, and events. When you query a user's learning path or a generic content endpoint, the API returns polymorphic data structures. A standard REST `GET` request will return arrays of objects where the `type` field dictates entirely different attribute schemas. If your AI agent is trying to parse a pathway, your custom MCP server must dynamically map the schema of a video payload versus a course payload. If you feed an LLM raw polymorphic JSON without rigorous schema definitions, the model will hallucinate available fields.

### Strict Pagination and Expiring Cursors
When extracting xAPI statements or fetching large lists of user completions, Degreed employs a strict cursor-based pagination system. These cursors are highly volatile. For instance, the next cursor for xAPI statements expires after just 2 minutes of idle time. If an LLM is doing multi-step reasoning, analyzing a batch of records, and taking longer than 2 minutes to request the next page, the cursor will die. Your MCP server must handle state management or explicitly instruct the LLM on exactly how to pass the `next_cursor` value back unmodified to prevent silent failures.

### Skills vs Skills+
The Degreed API maintains a complex taxonomy between standard organization skills and "Skills+" (their advanced ontology system). Mapping a user to a skill requires specific provider-code routing and proficiency level mappings. When an LLM wants to "endorse a user for Python," your custom integration code must translate that intent into the correct relationship payload, distinguishing between creating a new custom skill and associating an existing ontology ID. 

### Rate Limiting realities
Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the Degreed API returns an HTTP 429, Truto acts as a transparent proxy and passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The MCP client (or your orchestration layer) is entirely responsible for interpreting these headers and executing retry or backoff logic. Do not expect the MCP server to magically absorb rate limits.

## Degreed to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT calling the Degreed API, follow these steps. 

**What you need:**
- A Truto account with API access.
- A Degreed admin account to approve the OAuth consent.
- A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available.

### Step 1: Connect Degreed to Truto
In the Truto dashboard, navigate to **Integrated Accounts** -> **New Integrated Account**, select Degreed, and run through the OAuth flow. Truto securely stores the refresh token and handles the ongoing token lifecycle. Grab your `integrated_account_id` from the resulting dashboard page.

### Step 2: Generate the MCP Server
You can generate the self-contained MCP server URL either via the Truto UI or programmatically via the API.

**Method A: Via the Truto UI**
1. Navigate to the Integrated Account page for your new Degreed connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., restrict to `read` methods only).
5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<token>`).

**Method B: Via the API**
Alternatively, you can scope an MCP endpoint to that account programmatically. Filter by `methods` and `tags` to constrain exactly what ChatGPT can touch:

```bash
curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Degreed ChatGPT L&D Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["users", "skills", "pathways"]
    }
  }'
```

The response returns a JSON object containing the `url` field. That single URL carries all routing and authentication - treat it like a secret.

### Step 3: Connect the MCP Server to ChatGPT

Now, feed that URL to your ChatGPT environment. You can do this visually or via a local runner if you are testing custom agents.

**Method A: Via the ChatGPT UI**
1. Open ChatGPT and go to **Settings** -> **Apps** -> **Advanced settings**.
2. Ensure **Developer mode** is enabled.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name it "Degreed L&D Assistant".
5. Paste the Truto MCP URL into the Server URL field and click **Save**.

ChatGPT will immediately ping the `/initialize` endpoint, perform the handshake, and list the available Degreed tools.

**Method B: Via Manual Config File (for local agents/testing)**
If you are running a local agentic framework or testing with the official MCP SDKs, you can wrap the Truto endpoint using the Server-Sent Events (SSE) transport. 

Run the following command:
```bash
npx @modelcontextprotocol/server-sse --url https://api.truto.one/mcp/<YOUR_TOKEN>
```
This bridges the remote HTTP JSON-RPC endpoint to standard I/O, allowing local agent frameworks to consume the Degreed tools seamlessly.

## Hero Tools for Degreed Automation

Truto [automatically generates precise, JSON Schema-backed tools](https://truto.one/blog/how-do-mcp-servers-auto-generate-tools-from-api-documentation/) from Degreed's internal documentation. When an LLM calls a tool, the payload is parsed, validated, and proxied directly to the underlying Degreed REST endpoint. 

Here are the highest-leverage tools available for your ChatGPT agent.

### `list_all_degreed_user_user_skills`
Retrieves a complete list of all skills currently associated with a specific user. This is the foundation for any gap-analysis workflow. The tool schema explicitly instructs the LLM on how to handle the paginated cursor response.

> "Fetch all the registered skills for the employee with ID 98765. I need to know their current proficiency levels in AWS and Python."

### `create_a_degreed_user_skill`
Adds a new skill to a user's profile or updates an existing relationship. If the skill does not exist in the organization's ontology, Degreed creates it automatically. 

> "Endorse user 98765 with the skill 'Kubernetes Administration'. Set the proficiency level to intermediate."

### `list_all_degreed_pathways`
Searches the organization's catalog for existing learning pathways. This tool supports date-range filters and returns heavily nested relational data (including sections, lessons, and resources), which the LLM can parse to recommend content.

> "Find all learning pathways created in the last 30 days that are tagged for 'Leadership Training'."

### `create_a_degreed_pathway`
Generates an entirely new pathway in Degreed. The agent must supply the pathway details in the required schema format, and can include nested resources and visibility parameters. 

> "Create a new learning pathway titled 'Q3 AI Engineering Bootcamp'. Add a brief description and set the visibility to open for the engineering group."

### `list_all_degreed_user_required_learnings`
Fetches compliance or mandatory training requirements assigned to a specific user. This is crucial for building automated HR compliance auditing agents.

> "Check the required learnings for employee ID 44552. Let me know if they have any pending security compliance courses."

### `create_a_degreed_skill_plan`
Constructs a structured skill plan for a user. Skill plans in Degreed are used to target specific roles or career progression tracks. The LLM can dynamically generate the sections based on a user's stated goals.

> "Build a new skill plan for user 44552 aimed at the 'Senior Cloud Architect' role. Include sections for system design and advanced networking."

To view the complete inventory of available proxy tools, schemas, and endpoints, visit the [Degreed integration page](https://truto.one/integrations/detail/degreed).

## Workflows in Action

Connecting ChatGPT to Degreed unlocks complex, multi-step orchestration. By chaining tools together, the LLM acts as an autonomous Learning and Development coordinator. 

### 1. The Skill Gap Analysis and Recommendation Workflow

An employee asks ChatGPT for career advice regarding a promotion to a DevOps engineering role. The agent analyzes their current skills and recommends specific learning paths.

> "I want to move into a DevOps role. Can you look at my current skills, figure out what I'm missing, and recommend a learning path? My employee ID is 1045."

```mermaid
sequenceDiagram
    participant User
    participant Agent as ChatGPT Agent
    participant MCP as Truto MCP Server
    participant Degreed as Degreed API

    User->>Agent: "Check my skills and recommend a DevOps path"
    Agent->>MCP: Call list_all_degreed_user_user_skills(user_id: 1045)
    MCP->>Degreed: GET /users/1045/skills
    Degreed-->>MCP: Returns [Python, Git, Basic Linux]
    MCP-->>Agent: JSON response
    Agent->>Agent: Analyzes gap (Missing: Docker, K8s, CI/CD)
    Agent->>MCP: Call list_all_degreed_pathways(search: "DevOps")
    MCP->>Degreed: GET /pathways?filter[search]=DevOps
    Degreed-->>MCP: Returns ["Enterprise Kubernetes", "CI/CD Basics"]
    MCP-->>Agent: JSON response
    Agent-->>User: "You need Docker and K8s. I recommend the 'Enterprise Kubernetes' pathway."
```

**Step-by-step Execution:**
1. ChatGPT calls `list_all_degreed_user_user_skills` to retrieve the employee's existing competencies.
2. The LLM identifies the missing competencies required for a standard DevOps role.
3. ChatGPT calls `list_all_degreed_pathways` to query the organization's catalog for relevant training.
4. The agent returns a highly contextualized recommendation to the user.

### 2. Automated Onboarding Plan Generation

An IT admin needs to spin up a custom onboarding track for a new cohort of software engineers based on the specific tech stack of their assigned team.

> "Generate a new skill plan for our incoming backend engineers. They need to learn Go and Apache Kafka. Assign it to user ID 2088 and add their manager as a collaborator."

```mermaid
flowchart TD
    A["User Prompt:<br>Generate backend skill plan"] --> B["Agent parses intent"]
    B --> C["Call create_a_degreed_skill_plan<br>(Title: Backend Onboarding)"]
    C --> D["Call create_a_degreed_skill_plan_section<br>(Topic: Go Fundamentals)"]
    D --> E["Call create_a_degreed_skill_plan_section<br>(Topic: Apache Kafka)"]
    E --> F["Call create_a_degreed_skill_plan_collaborator<br>(Add Manager ID)"]
    F --> G["Return Success to User"]
```

**Step-by-step Execution:**
1. ChatGPT calls `create_a_degreed_skill_plan` to initialize the empty structure.
2. The agent calls `create_a_degreed_skill_plan_section` twice, once for Go and once for Kafka, attaching them to the newly created plan ID.
3. The agent calls `create_a_degreed_skill_plan_collaborator` to grant edit access to the engineering manager.
4. ChatGPT returns the direct link to the new skill plan to the user.

### 3. Compliance Audit and Remediation

An HR manager wants to ensure a specific employee is up to date on required security training and take action if they are falling behind.

> "Check the required learnings for employee 505. If they haven't finished the Data Privacy course, add a new required learning task with a strict deadline."

**Step-by-step Execution:**
1. ChatGPT calls `list_all_degreed_user_required_learnings` passing the user ID.
2. The agent parses the returned array, checking the `status` fields against the "Data Privacy" course ID.
3. Recognizing the course is incomplete or missing, the agent calls `create_a_degreed_required_learning` to assign the content forcefully to the employee's queue.
4. The agent informs the HR manager that the requirement has been successfully enforced.

## Security and Access Control

Giving an LLM unconstrained write access to an enterprise LMS is a massive security risk. Truto's MCP architecture enforces strict constraints at the server level, meaning the LLM physically cannot execute unauthorized actions, regardless of how it is prompted.

*   **Method Filtering:** By passing `config.methods: ["read"]` during MCP server creation, you strip out all `create`, `update`, and `delete` tools. The LLM will only see `list` and `get` operations, making the server strictly read-only.
*   **Tag Filtering:** Degreed endpoints are tagged by resource type. You can restrict a server by passing `config.tags: ["skills", "pathways"]`. This ensures the agent cannot query sensitive endpoints like `salaries` or `identities`.
*   **Secondary Authentication (`require_api_token_auth`):** If enabled, possessing the MCP URL is not enough. The client must also pass a valid Truto API bearer token in the headers, adding a crucial layer of enterprise access control.
*   **Time-to-Live (`expires_at`):** You can generate ephemeral MCP servers by providing an ISO timestamp. Once expired, the server URL instantly invalidates. This is ideal for granting a contractor or temporary AI agent short-lived access to Degreed data.

## Moving Forward

Building a custom API integration layer to connect LLMs to Degreed involves parsing polymorphic payloads, managing volatile pagination cursors, and writing endless TypeScript boilerplate for JSON schemas. 

Truto eliminates this entire class of technical debt. By dynamically deriving tools from actual integration schemas and securing them behind a stateless MCP routing layer, you can ship enterprise-grade AI agents in hours, not sprints. 

Stop wrangling API docs. Let the platform generate your tools for you.