How to Connect to Live PingOne Data from Claude Agent SDK (via CData Connect AI)

Jerod Johnson
Jerod Johnson
Director, Technology Evangelism
Leverage CData Connect AI to enable Claude Agent SDK applications to securely read and take actions on your PingOne data for you.

Claude Agent SDK is a powerful framework from Anthropic for building production-ready AI agents with stateful conversations, automatic context management, and native MCP (Model Context Protocol) tool integration. When combined with CData Connect AI, you can leverage Claude Agent SDK to build intelligent agents that interact with your PingOne data in real-time through natural language queries. This article outlines the process of connecting to PingOne using Connect AI and configuring a Claude Agent SDK application to interact with your PingOne data.

CData Connect AI offers a dedicated cloud-to-cloud interface for connecting to PingOne data. The CData Connect AI Remote MCP Server enables secure communication between Claude Agent SDK applications and PingOne. This allows your agents to read from and take actions on your PingOne data, all without the need for data replication to a natively supported database. With its inherent optimized data processing capabilities, CData Connect AI efficiently channels all supported SQL operations, including filters and JOINs, directly to PingOne. This leverages server-side processing to swiftly deliver the requested PingOne data.

In this article, we show how to configure a Claude Agent SDK application to conversationally explore (or Vibe Query) your data using natural language. With Connect AI you can build agents with access to live PingOne data, plus hundreds of other sources.

Step 1: Configure PingOne Connectivity for Claude Agent SDK

Connectivity to PingOne from Claude Agent SDK applications is made possible through CData Connect AI Remote MCP. To interact with PingOne data from your agent, we start by creating and configuring a PingOne connection in CData Connect AI.

  1. Log into Connect AI, click Sources, and then click Add Connection
    2. Adding a Connection
  2. Select "PingOne" from the Add Connection panel
    3. Selecting a data source
  3. Enter the necessary authentication properties to connect to PingOne.

    To connect to PingOne, configure these properties:

    • Region: The region where the data for your PingOne organization is being hosted.
    • AuthScheme: The type of authentication to use when connecting to PingOne.
    • Either WorkerAppEnvironmentId (required when using the default PingOne domain) or AuthorizationServerURL, configured as described below.

    Configuring WorkerAppEnvironmentId

    WorkerAppEnvironmentId is the ID of the PingOne environment in which your Worker application resides. This parameter is used only when the environment is using the default PingOne domain (auth.pingone). It is configured after you have created the custom OAuth application you will use to authenticate to PingOne, as described in Creating a Custom OAuth Application in the Help documentation.

    First, find the value for this property:

    1. From the home page of your PingOne organization, move to the navigation sidebar and click Environments.
    2. Find the environment in which you have created your custom OAuth/Worker application (usually Administrators), and click Manage Environment. The environment's home page displays.
    3. In the environment's home page navigation sidebar, click Applications.
    4. Find your OAuth or Worker application details in the list.
    5. Copy the value in the Environment ID field. It should look similar to: 
      WorkerAppEnvironmentId='11e96fc7-aa4d-4a60-8196-9acf91424eca'

    Now set WorkerAppEnvironmentId to the value of the Environment ID field.

    Configuring AuthorizationServerURL

    AuthorizationServerURL is the base URL of the PingOne authorization server for the environment where your application is located. This property is only used when you have set up a custom domain for the environment, as described in the PingOne platform API documentation. See Custom Domains.

    Authenticating to PingOne with OAuth

    PingOne supports both OAuth and OAuthClient authentication. In addition to performing the configuration steps described above, there are two more steps to complete to support OAuth or OAuthCliet authentication:

    • Create and configure a custom OAuth application, as described in Creating a Custom OAuth Application in the Help documentation.
    • To ensure that the driver can access the entities in Data Model, confirm that you have configured the correct roles for the admin user/worker application you will be using, as described in Administrator Roles in the Help documentation.
    • Set the appropriate properties for the authscheme and authflow of your choice, as described in the following subsections.

    OAuth (Authorization Code grant)

    Set AuthScheme to OAuth.

    Desktop Applications

    Get and Refresh the OAuth Access Token

    After setting the following, you are ready to connect:

    • InitiateOAuth: GETANDREFRESH. To avoid the need to repeat the OAuth exchange and manually setting the OAuthAccessToken each time you connect, use InitiateOAuth.
    • OAuthClientId: The Client ID you obtained when you created your custom OAuth application.
    • OAuthClientSecret: The Client Secret you obtained when you created your custom OAuth application.
    • CallbackURL: The redirect URI you defined when you registered your custom OAuth application. For example: https://localhost:3333

    When you connect, the driver opens PingOne's OAuth endpoint in your default browser. Log in and grant permissions to the application. The driver then completes the OAuth process:

    1. The driver obtains an access token from PingOne and uses it to request data.
    2. The OAuth values are saved in the location specified in OAuthSettingsLocation, to be persisted across connections.

    The driver refreshes the access token automatically when it expires.

    For other OAuth methods, including Web Applications, Headless Machines, or Client Credentials Grant, refer to the Help documentation.

    Configuring a connection (Salesforce is shown)
  4. Click Save & Test
  5. Navigate to the Permissions tab in the Add PingOne Connection page and update the User-based permissions. Updating permissions

Add a Personal Access Token

A Personal Access Token (PAT) is used to authenticate the connection to Connect AI from your Claude Agent SDK application. It is best practice to create a separate PAT for each service to maintain granularity of access.

  1. Click on the Gear icon () at the top right of the Connect AI app to open the settings page.
  2. On the Settings page, go to the Access Tokens section and click Create PAT.
  3. Give the PAT a name and click Create. Creating a new PAT
  4. The personal access token is only visible at creation, so be sure to copy it and store it securely for future use.

With the connection configured and a PAT generated, we are ready to connect to PingOne data from your Claude Agent SDK application.

Step 2: Set Up Your Claude Agent SDK Application for CData Connect AI

Follow these steps to configure your Claude Agent SDK application to connect to CData Connect AI. You can use our pre-built agent chatbot as a starting point, available at https://github.com/CDataSoftware/connect-ai-claude-agent, or follow the instructions below to create your own.

Prerequisites

  1. Python 3.8 or higher installed on your system
  2. An Anthropic API key (obtain from https://console.anthropic.com/)
  3. Install the required dependencies: 
    pip install claude-agent-sdk python-dotenv requests

Configuration Steps

  1. Create a new Python project directory and navigate to it: 
    mkdir my-cdata-agent
cd my-cdata-agent
  2. Set up your environment variables. Create a .env file in your project root with the following variables: 
    ANTHROPIC_API_KEY=your_anthropic_api_key
[email protected]
CDATA_ACCESS_TOKEN=your_personal_access_token
    Replace your_anthropic_api_key with your Anthropic API key, [email protected] with your Connect AI email address, and your_personal_access_token with the Personal Access Token created in Step 1.

Building Your Claude Agent SDK Application

With the setup for CData Connect AI completed, we are ready to build our agent application. We will walk through the key components needed to create a production-ready AI agent with stateful conversations and native MCP tool integration. For this example, we will create a single Python file (agent.py), which includes the MCP client, agent chatbot, and interactive interface.

Imports and Environment Setup

To start, import the necessary libraries and load environment variables. We need the Claude Agent SDK for agent functionality, the requests library for HTTP communication with the MCP server, and standard Python libraries for async operations and authentication. 


#!/usr/bin/env python3
import os
import json
import base64
import asyncio
from typing import Optional, Dict, Any
from functools import partial
import requests
from claude_agent_sdk import query, ClaudeSDKClient, ClaudeAgentOptions, tool, create_sdk_mcp_server
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

Creating the MCP Client

The MCPClient class handles communication with the CData Connect AI MCP server over HTTP. It manages authentication using Basic Auth (email and personal access token), sends JSON-RPC requests to the MCP server, and parses Server-Sent Events (SSE) responses. The client provides two key methods: list_tools() to discover available tools and call_tool() to execute MCP tools. 


class MCPClient:
    """Client for interacting with CData Connect AI MCP server over HTTP."""

    def __init__(self, server_url: str, email: Optional[str] = None, access_token: Optional[str] = None):
        self.server_url = server_url.rstrip('/')
        self.session = requests.Session()

        # Set default headers for MCP JSON-RPC
        self.session.headers.update({
            'Content-Type': 'application/json',
            'Accept': 'application/json, text/event-stream'
        })

        if email and access_token:
            # Basic authentication: email:personal_access_token
            credentials = f"{email}:{access_token}"
            encoded_credentials = base64.b64encode(credentials.encode()).decode()
            self.session.headers.update({
                'Authorization': f'Basic {encoded_credentials}'
            })

    def _parse_sse_response(self, response_text: str) -> dict:
        """Parse Server-Sent Events (SSE) response."""
        for line in response_text.split('\n'):
            if line.startswith('data: '):
                data_json = line[6:]  # Remove 'data: ' prefix
                return json.loads(data_json)
        raise ValueError("No data found in SSE response")

    def list_tools(self) -> list:
        """Get available tools from the MCP server."""
        response = self.session.post(
            self.server_url,
            json={
                "jsonrpc": "2.0",
                "method": "tools/list",
                "params": {},
                "id": 1
            }
        )
        response.raise_for_status()
        result = self._parse_sse_response(response.text)
        return result.get("result", {}).get("tools", [])

    def call_tool(self, tool_name: str, arguments: dict) -> dict:
        """Call a tool on the MCP server."""
        response = self.session.post(
            self.server_url,
            json={
                "jsonrpc": "2.0",
                "method": "tools/call",
                "params": {
                    "name": tool_name,
                    "arguments": arguments
                },
                "id": 2
            }
        )
        response.raise_for_status()
        result = self._parse_sse_response(response.text)
        return result.get("result", {})

Building the Agent Chatbot Class

The MCPAgentChatbot class is the core of our application. It connects the MCP client to the Claude Agent SDK, creating a production-ready AI agent with stateful conversations and automatic context management. The class performs several key functions during initialization: it creates an MCP client instance, discovers available tools from the CData Connect AI MCP server, wraps each MCP tool for use with the Agent SDK, and creates an SDK-compatible MCP server.

Initializing the Agent and Loading Tools

When the MCPAgentChatbot is initialized, it connects to the CData Connect AI MCP server and retrieves all available tools. These tools are then wrapped to be compatible with the Claude Agent SDK's tool framework. 


class MCPAgentChatbot:
    """
    Production-ready AI agent chatbot for CData Connect AI.
    Uses Claude Agent SDK for stateful conversations and automatic context management.
    """

    def __init__(self, mcp_server_url: str, email: Optional[str] = None, access_token: Optional[str] = None):
        self.mcp_client = MCPClient(mcp_server_url, email, access_token)

        # Load available tools from MCP server
        print("Connecting to CData Connect AI MCP server...")
        self.mcp_tools_list = self.mcp_client.list_tools()
        print(f"✓ Loaded {len(self.mcp_tools_list)} tools from MCP server")

        # Create custom MCP tool wrappers for the Agent SDK
        self.agent_tools = self._create_agent_tools()

        # Create MCP server for Agent SDK
        self.mcp_server = create_sdk_mcp_server(
            name="cdata_connect",
            tools=self.agent_tools
        )

Creating Tool Wrappers for the Agent SDK

The _create_agent_tools() method transforms MCP tool definitions into Agent SDK-compatible tools. For each tool discovered from the MCP server, it creates a wrapper using the @tool decorator with the tool's name, description, and input schema. The _tool_handler() method is called whenever a tool is executed - it forwards the request to the MCP server and formats the response for the Agent SDK. 


    async def _tool_handler(self, tool_name: str, args: Dict[str, Any]) -> Dict[str, Any]:
        """Call the MCP tool and return results."""
        result = self.mcp_client.call_tool(tool_name, args)
        return {
            "content": [{
                "type": "text",
                "text": json.dumps(result, indent=2)
            }]
        }

    def _create_agent_tools(self) -> list:
        """Create Agent SDK tool wrappers for MCP tools."""
        agent_tools = []
        for tool_info in self.mcp_tools_list:
            tool_name = tool_info.get("name")
            tool_description = tool_info.get("description", "")
            tool_schema = tool_info.get("inputSchema", {})

            agent_tool = tool(
                name=tool_name,
                description=tool_description,
                input_schema=tool_schema
            )(partial(self._tool_handler, tool_name))

            agent_tools.append(agent_tool)
        return agent_tools

Managing Stateful Conversation Sessions

One of the key features of the Claude Agent SDK is its ability to maintain stateful conversations with automatic context management. The create_session() method creates a ClaudeSDKClient instance configured with a system prompt, access to the MCP tools, and permission settings. The chat_session() method sends a user message and retrieves the agent's response, maintaining conversation context automatically. 


    def create_session(self) -> ClaudeSDKClient:
        """Create a stateful conversation session."""
        options = ClaudeAgentOptions(
            system_prompt="You are a helpful assistant with access to PingOne data through CData Connect AI.",
            mcp_servers={"cdata_connect": self.mcp_server},
            permission_mode="bypassPermissions"
        )
        return ClaudeSDKClient(options=options)

    async def chat_session(self, client: ClaudeSDKClient, user_message: str) -> str:
        """Send a message in a stateful session."""
        await client.query(user_message)
        async for message in client.receive_response():
            if hasattr(message, 'result'):
                return str(message.result)
        return ""

Creating the Interactive Interface

The main() function brings everything together to create an interactive chatbot. It loads credentials from environment variables, initializes the MCPAgentChatbot, creates a stateful session, and starts an interactive loop where users can chat with the agent. The session is managed using Python's async context manager (async with), which ensures proper cleanup of resources and API connections. 


async def main():
    """Run the agent in interactive mode."""
    MCP_SERVER_URL = "https://mcp.cloud.cdata.com/mcp/"
    CDATA_EMAIL = os.environ.get("CDATA_EMAIL")
    CDATA_ACCESS_TOKEN = os.environ.get("CDATA_ACCESS_TOKEN")

    print("=== CData Connect AI Agent ===\n")

    chatbot = MCPAgentChatbot(MCP_SERVER_URL, CDATA_EMAIL, CDATA_ACCESS_TOKEN)
    client = chatbot.create_session()

    async with client:
        while True:
            user_input = input("You: ").strip()
            if user_input.lower() in ['quit', 'exit', 'q']:
                break
            response = await chatbot.chat_session(client, user_input)
            print(f"\nAssistant: {response}\n")


if __name__ == "__main__":
    asyncio.run(main())

Running Your Agent

  1. Save all the code sections above into a single file named agent.py in your project directory. Alternatively, you can download the complete example from https://github.com/CDataSoftware/connect-ai-claude-agent.
  2. Run your agent application: 
    python agent.py
  3. Start interacting with your PingOne data through natural language queries. Your agent now has access to your PingOne data through the CData Connect AI MCP Server.

Step 3: Build Intelligent Agents with Live PingOne Data Access

With your Claude Agent SDK application configured and connected to CData Connect AI, you can now build sophisticated agents that interact with your PingOne data using natural language. The MCP integration provides your agents with powerful data access capabilities.

Available MCP Tools for Your Agent

Your Claude Agent SDK application has access to the following CData Connect AI MCP tools:

  • queryData: Execute SQL queries against connected data sources and retrieve results
  • getCatalogs: Retrieve a list of available connections from CData Connect AI
  • getSchemas: Retrieve database schemas for a specific catalog
  • getTables: Retrieve database tables for a specific catalog and schema
  • getColumns: Retrieve column metadata for a specific table
  • getProcedures: Retrieve stored procedures for a specific catalog and schema
  • getProcedureParameters: Retrieve parameter metadata for stored procedures
  • executeProcedure: Execute stored procedures with parameters

Key Features of Claude Agent SDK

The Claude Agent SDK provides several production-ready features that make it ideal for building AI agents:

  • Automatic Context Management: No manual conversation history tracking needed - the SDK handles context automatically
  • Stateful Conversations: Maintain context across multiple turns for natural, flowing interactions
  • Native Tool Integration: Tools are first-class citizens with automatic calling lifecycle and error handling
  • Context Compaction: Automatic context compaction when approaching token limits
  • Async/Await Architecture: Modern Python async patterns for better performance
  • Permission Controls: Fine-grained control over tool permissions and execution

Example Use Cases

Here are some examples of what your Claude Agent SDK applications can do with live PingOne data access:

  • Data Analysis Agent: Build an agent that analyzes trends, patterns, and anomalies in your PingOne data
  • Report Generation Agent: Create agents that generate custom reports based on natural language requests
  • Data Quality Agent: Develop agents that monitor and validate data quality in real-time
  • Business Intelligence Agent: Build agents that answer complex business questions by querying multiple data sources
  • Interactive Chatbot: Create chatbots that can answer questions about your PingOne data in natural language
  • Automated Workflow Agent: Create agents that trigger actions based on data conditions in PingOne

Testing Your Agent

Once your agent is running, you can interact with it through natural language queries. For example:

  • "Show me all customers from the last 30 days"
  • "What are the top performing products this quarter?"
  • "Analyze sales trends and identify anomalies"
  • "Generate a summary report of active projects"
  • "Find all records that match specific criteria"

Your Claude Agent SDK application will automatically translate these natural language queries into appropriate SQL queries and execute them against your PingOne data through the CData Connect AI MCP Server, providing real-time insights without requiring users to write complex SQL or understand the underlying data structure.

Advanced Configuration

Programmatic Usage

You can also use the Claude Agent SDK programmatically for one-off queries or integration into larger applications:

One-off Queries

from claude_agent_sdk import query, ClaudeAgentOptions

async def single_query():
    options = ClaudeAgentOptions(
        system_prompt="You are a data analyst assistant.",
        mcp_servers={"cdata_connect": mcp_server},
        permission_mode="bypassPermissions"
    )

    response = await query(
        prompt="What data sources are available?",
        options=options
    )

    async for message in response:
        if hasattr(message, 'result'):
            print(message.result)

Stateful Multi-Turn Conversations

async def conversation():
    client = chatbot.create_session()

    async with client:
        # First query
        response1 = await chatbot.chat_session(client, "List my data sources")
        print(response1)

        # Follow-up query with context
        response2 = await chatbot.chat_session(client, "Tell me more about the first one")
        print(response2)

Permission Modes

Claude Agent SDK offers different permission modes for tool execution:

  • default: Prompts user for approval before executing tools
  • acceptEdits: Automatically accepts edit operations
  • bypassPermissions: Auto-approves all tools (recommended for CLI applications)
  • plan: Agent plans actions before execution

Get CData Connect AI

To get live data access to hundreds of SaaS, Big Data, and NoSQL sources directly from your Claude Agent SDK applications, try CData Connect AI today!

Ready to get started?

Learn more about CData Connect AI or sign up for free trial access:

Free Trial

In this article

Related articles