---
title: "Connect Dvinci to ChatGPT: Automate candidate and job management"
slug: connect-dvinci-to-chatgpt-automate-candidate-and-job-management
date: 2026-10-13
author: Nidhi KN
categories: ["AI & Agents"]
excerpt: "Learn how to connect Dvinci to ChatGPT using a managed MCP server. Automate candidate tracking, job publications, and hiring workflows with AI agents."
tldr: "Connect Dvinci to ChatGPT via a managed MCP server to orchestrate candidate profiles, job openings, and applications. This guide covers UI and API setup, security controls, and real-world AI agent workflows."
canonical: https://truto.one/blog/connect-dvinci-to-chatgpt-automate-candidate-and-job-management/
---

# Connect Dvinci to ChatGPT: Automate candidate and job management


If you want to connect Dvinci to ChatGPT so your AI agents can source candidates, manage job postings, parse resumes, and update application statuses, you need a [Model Context Protocol (MCP) server](https://truto.one/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 Dvinci's REST APIs. 

If your team uses Claude, check out our guide on [connecting Dvinci to Claude](https://truto.one/connect-dvinci-to-claude-manage-hiring-requests-and-job-postings/) or explore our broader architectural overview on [connecting Dvinci to AI Agents](https://truto.one/connect-dvinci-to-ai-agents-orchestrate-applicant-tracking-tasks/).

Giving a Large Language Model (LLM) read and write access to an [Applicant Tracking System (ATS)](https://truto.one/what-are-ats-integrations-2026-architecture-strategy-guide/) is a massive engineering challenge. You have to handle complex relational hiring data payloads, map dynamic custom fields to MCP tool definitions, and deal with strict compliance requirements for candidate records. Every time a developer adds a new recruitment workflow, your custom server code must be updated, redeployed, and tested. 

This guide breaks down exactly how to use Truto to [generate a secure, managed MCP server](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) for Dvinci, connect it natively to ChatGPT, and execute complex hiring operations using natural language.

> Stop writing [boilerplate ATS integration code](https://truto.one/what-are-ats-integrations-2026-architecture-strategy-guide/). Let Truto generate secure, managed MCP servers for your HR AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Dvinci API

A custom MCP server is a self-hosted integration layer. While the [open MCP standard](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/) provides a predictable way for models to discover tools, implementing it against Dvinci's highly relational ATS data model is exceptionally painful. 

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

### Application State vs Person Identity
In many simpler systems, a "User" is a single flat record. In Dvinci, the data model heavily separates the candidate profile (`dvinci_persons`) from their active job pursuit (`dvinci_applications`). An LLM asking to "reject John Doe for the Engineering role" cannot just update a status field on the person object. Your MCP server must first locate the person, find their application tied to the specific job opening, and execute a state change using the dedicated `dvinci_applications_change_status` endpoint. If your tool definitions do not enforce this relational boundary, ChatGPT will hallucinate payloads attempting to write status fields directly to the person object.

### Strict History Auditing and Upsert Logic
Applicant tracking systems require immutable audit logs for compliance (e.g., EEOC reporting, GDPR). Dvinci enforces this through dedicated history endpoints like `dvinci_application_history_upsert_entry`. You cannot simply PATCH a record to change a past event; you must format a rigid historical entry payload. If your MCP tools expose generic "update" methods without the proper JSON schema constraints, LLMs will fail the rigorous validation rules of the history endpoints.

### Handling 429 Rate Limits and the IETF Spec
When an AI agent runs a bulk operation - like parsing 50 resumes or extracting a high volume of candidate data - it will inevitably hit Dvinci's API rate limits. 

Truto normalizes upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. However, **Truto does not automatically retry, throttle, or apply backoff on rate limit errors.** When Dvinci returns an HTTP 429, Truto immediately passes that error back to the caller. The AI agent or LLM orchestrator (like LangChain or a custom ChatGPT loop) is strictly responsible for reading the `ratelimit-reset` header, pausing execution, and retrying the tool call. Building a custom MCP server means you have to build this header normalization and propagation layer yourself.

### Deprecated Route Navigation
Enterprise ATS platforms evolve, leaving legacy routes intact for backward compatibility. The Dvinci integration contains specific tools like `dvinci_job_publications_delete_deprecated`. A custom MCP server must intentionally curate which endpoints are exposed as AI tools via human-readable descriptions. If you just naively convert an OpenAPI spec to an MCP server, you will expose deprecated routes to the LLM, leading to unpredictable system behavior and legacy data corruption.

## Step 1: Generating the Dvinci MCP Server

Truto's MCP architecture bypasses manual tool coding. It dynamically derives tool definitions from the Dvinci integration's resources and human-readable documentation records. 

You can generate an MCP server scoped to a specific Dvinci account using either the Truto UI or the API.

### Method 1: Via the Truto UI
1. Log into your Truto dashboard and navigate to **Integrated Accounts**.
2. Select your connected Dvinci account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., allowing only `read` methods, or filtering by `persons` tags).
6. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/<secure_token>`).

### Method 2: Via the Truto API
For automated environments, you can generate the MCP server programmatically. This creates a secure token in Truto's KV storage that routes directly to your Dvinci tenant.

```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": "ChatGPT Dvinci Hiring Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["applications", "persons", "jobs"]
    }
  }'
```

The response returns a JSON payload containing your `url`. Treat this URL as a sensitive credential - it contains the cryptographic token required to execute Dvinci tool calls.

## Step 2: Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you must register it with ChatGPT so the LLM can invoke the Dvinci tools.

### Method A: Via the ChatGPT UI (Custom Connectors)
If you are using a ChatGPT Pro, Plus, Business, Enterprise, or Education account with Developer Mode enabled:
1. Open ChatGPT and navigate 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:** "Dvinci ATS"
5. **Server URL:** Paste your Truto MCP URL.
6. Save the configuration. ChatGPT will immediately perform the MCP handshake, pulling in the available Dvinci tools dynamically.

### Method B: Via Manual Config File (SSE Transport)
If you are running a local agent, a custom LangChain implementation, or a desktop client that requires a standard configuration file, you can bridge the HTTP endpoint using the official Server-Sent Events (SSE) adapter.

```json
{
  "mcpServers": {
    "dvinci_ats": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<YOUR_SECURE_TOKEN>"
      ]
    }
  }
}
```
This configuration instructs the MCP client to route JSON-RPC tool invocations over SSE to the Truto proxy, which translates them into authenticated REST calls against Dvinci.

## Dvinci Hero Tools for ChatGPT

When ChatGPT handshakes with the Truto MCP server, it receives a curated list of tools. Because Truto uses a flat input namespace, the query parameters and body parameters are merged seamlessly for the LLM to populate. 

Here are the highest-leverage operations for automating Dvinci.

### list_all_dvinci_job_openings
Fetches a paginated list of active job openings in the ATS. 

*Usage Note:* This tool automatically injects `limit` and `next_cursor` properties. ChatGPT will handle cursor traversal if you ask it to find a specific requisition across a large dataset.

> "Fetch all current job openings in the Engineering department. If there are more than 50, paginate through the results until you find the requisition for 'Senior Backend Developer'."

### create_a_dvinci_person
Creates a new candidate profile in the Dvinci database.

*Usage Note:* This tool handles the core candidate identity (name, email, phone). It does not automatically apply them to a job. That requires a subsequent application tool call.

> "Create a new candidate profile for Jane Smith. Her email is jane.smith@example.com and her phone number is 555-0199. Return the newly generated person ID."

### create_a_dvinci_application
Links an existing candidate profile to a specific job opening.

*Usage Note:* This tool requires the `person_id` and the `job_opening_id`. This strict relational model ensures data integrity in the ATS.

> "Take person ID 1042 and apply them to job opening ID 993. Set their initial source as 'LinkedIn Sourcing'."

### dvinci_applications_change_status
A custom method that moves a candidate through the hiring pipeline.

*Usage Note:* This is preferred over a raw update, as changing statuses in Dvinci often triggers internal ATS webhooks, automated emails, or compliance checks.

> "Move the application for candidate 1042 on job 993 to the 'Technical Interview' status."

### dvinci_hiring_requests_get_by_external_id
Retrieves a hiring request using an identifier from a third-party system (like Workday or BambooHR).

*Usage Note:* Critical for HR ops agents syncing headcount approvals between the core HRIS and Dvinci.

> "Look up the hiring request in Dvinci matching the external Workday ID 'WD-REQ-4421'."

### dvinci_application_history_upsert_entry
Safely logs an interaction, note, or historical event to a candidate's application file.

*Usage Note:* Requires strict JSON schemas dictating the event type and timestamp. Truto validates this before forwarding to Dvinci.

> "Add a history entry to application ID 8812 noting that the candidate passed the screening call today at 2 PM, with the note: 'Strong communication skills, proceed to hiring manager.'"

To see the complete list of available Dvinci tools, including endpoints for onboarding attachments, user groups, and organizational units, visit the [Dvinci integration page](https://truto.one/integrations/detail/dvinci).

## Workflows in Action

Exposing Dvinci to ChatGPT unlocks powerful agentic workflows for recruiters and HR operations teams.

### Scenario 1: Autonomous Candidate Sourcing and Application
**Persona:** Technical Recruiter

> "I just found a great prospect named Alex Chen (alex.chen@example.com). Check if we have an open role for 'DevOps Engineer'. If we do, create a profile for Alex, apply him to that role, and move his application straight to the 'Screening' phase."

1. ChatGPT calls `list_all_dvinci_job_openings` filtering for the title "DevOps Engineer" to retrieve the `job_opening_id`.
2. ChatGPT calls `create_a_dvinci_person` with Alex's contact details, capturing the new `person_id`.
3. ChatGPT calls `create_a_dvinci_application` using both IDs to tie Alex to the role.
4. ChatGPT calls `dvinci_applications_change_status` to advance the application to "Screening".

*Result:* The user gets a confirmation that the candidate was fully entered into the ATS and staged for screening, eliminating four manual UI operations.

### Scenario 2: Synchronizing Headcount Approvals
**Persona:** HR Operations Manager

> "Look up hiring request 'REQ-2024-88' from our external finance system. If it exists in Dvinci, check if it's approved. If it is, update the corresponding job opening to 'Published' status."

1. ChatGPT calls `dvinci_hiring_requests_get_by_external_id` passing the finance ID.
2. ChatGPT inspects the JSON response to verify the internal approval status.
3. ChatGPT extracts the linked `job_opening_id` from the request payload.
4. ChatGPT calls `update_a_dvinci_job_opening_by_id` to adjust the publication status to active.

*Result:* The user bridges a gap between finance software and the ATS using a simple natural language command.

```mermaid
sequenceDiagram
    participant User as User Prompt
    participant ChatGPT as ChatGPT (MCP Client)
    participant Truto as Truto MCP Server
    participant Dvinci as Dvinci API

    User ->> ChatGPT: "Move candidate 891 to Interview phase"
    ChatGPT ->> Truto: tools/call (dvinci_applications_change_status)
    Truto ->> Dvinci: POST /applications/891/status
    Dvinci -->> Truto: HTTP 200 OK
    Truto -->> ChatGPT: JSON-RPC Result
    ChatGPT -->> User: "Candidate moved successfully."
```

## Security and Access Control

When connecting ChatGPT to sensitive hiring data, you must enforce the principle of least privilege. Truto MCP servers provide four layers of security to control LLM access:

*   **Method Filtering:** Configure the `config.methods` array (e.g., `["read"]`) when generating the server to explicitly block ChatGPT from executing `create`, `update`, or `delete` tools across the entire ATS.
*   **Tag Filtering:** Use `config.tags` (e.g., `["jobs", "hiring_requests"]`) to expose only specific functional areas, ensuring the LLM cannot see or interact with confidential payroll or onboarding endpoints.
*   **Expiration (TTL):** Set an `expires_at` ISO datetime when creating the MCP server. Truto schedules a Durable Object alarm to automatically tear down the server and purge the KV credentials, perfect for temporary contractor access or limited-time audit agents.
*   **Extra Authentication:** Enable `require_api_token_auth` to force the MCP client to pass a valid Truto API token in the `Authorization` header. This ensures that even if an MCP URL is leaked in a log file, it cannot be invoked without a secondary layer of organizational authentication.

## Final Thoughts

Connecting Dvinci to ChatGPT fundamentally changes how HR teams interact with their Applicant Tracking System. By utilizing a [managed MCP architecture](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/), engineering teams avoid the grueling work of writing custom JSON schema parsers, maintaining REST API boilerplates, and hardcoding tool definitions. 

Truto's documentation-driven generation ensures that your AI agents always have up-to-date access to Dvinci's endpoints - from basic job publishing to complex compliance history updates - allowing your organization to focus on building intelligent hiring workflows instead of maintaining integration infrastructure.