> ## Documentation Index
> Fetch the complete documentation index at: https://docs.stackone.com/llms.txt
> Use this file to discover all available pages before exploring further.
# OpenAI Integration
> Build AI agents with OpenAI Functions using the StackOne Python SDK
export const GitHubCode = ({url, lang, title, children}) => {
const urlMatch = url?.match(/https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/blob\/([^\/]+)\/(.+?)(?:#L(\d+)(?:-L(\d+))?)?$/);
const owner = urlMatch?.[1];
const repo = urlMatch?.[2];
const branch = urlMatch?.[3];
const filePath = urlMatch?.[4];
const startLine = urlMatch?.[5];
const endLine = urlMatch?.[6];
const getDisplayTitle = () => {
if (title) return title;
if (!filePath) return 'source';
const parts = filePath.split('/');
if (parts.length >= 2) {
return parts.slice(-2).join('/');
}
return parts[parts.length - 1];
};
const displayPath = filePath || 'source';
const displayTitle = getDisplayTitle();
const lineInfo = startLine ? endLine ? `#L${startLine}-L${endLine}` : `#L${startLine}` : '';
const fullUrl = url + (lineInfo && !url.includes('#L') ? lineInfo : '');
const encodedUrl = encodeURIComponent(fullUrl);
const iframeSrc = `https://emgithub.com/iframe.html?target=${encodedUrl}&style=github&type=code&showBorder=on&showLineNumbers=on&showFileMeta=on`;
return ;
};
Build AI agents that can interact with business systems using OpenAI's function calling atop StackOne's infrastructure: thousands of ready-to-run tools exposed over RPC with unified MCP and A2A interfaces.
## Overview
* **Function calling** with business data access
* **Conversational agents** with tool execution
* **Multi-step workflow** automation
* **Real-time data** integration
```python theme={null}
import json
from openai import OpenAI
from stackone_ai import StackOneToolSet
# Initialise clients
client = OpenAI()
toolset = StackOneToolSet()
# Fetch StackOne tools and convert to OpenAI format
tools = toolset.fetch_tools(
actions=['workday_get_worker', 'workday_list_workers'],
account_ids=['your-account-id']
)
openai_tools = tools.to_openai()
# Create an AI agent with tool access
response = client.chat.completions.create(
model="gpt-5.4",
messages=[
{
"role": "system",
"content": "You are an HR assistant with access to employee data."
},
{
"role": "user",
"content": "How many employees are in engineering?"
}
],
tools=openai_tools,
tool_choice="auto"
)
# Handle tool calls
message = response.choices[0].message
if message.tool_calls:
for tool_call in message.tool_calls:
tool = tools.get_tool(tool_call.function.name)
if tool:
result = tool.execute(tool_call.function.arguments)
print(f"Result: {result}")
```
## Example
## Agent-Driven Search
Let the LLM discover and execute tools on its own. Instead of loading all tools upfront, pass `tool_search` + `tool_execute` and the LLM finds what it needs:
```python theme={null}
from stackone_ai import StackOneToolSet
toolset = StackOneToolSet(
search={"method": "semantic", "top_k": 3},
execute={"account_ids": ["your-account-id"]},
)
# LLM receives only 2 tools - it searches and executes autonomously
openai_tools = toolset.openai(mode="search_and_execute")
response = client.chat.completions.create(
model="gpt-5.4",
messages=messages,
tools=openai_tools,
tool_choice="auto",
)
# Execute tool calls
for tool_call in response.choices[0].message.tool_calls:
result = toolset.execute(tool_call.function.name, tool_call.function.arguments)
```
See [Tool Search](/agents/python/tool-search#agent-driven-search) for the full agent loop example.
## Next Steps
* [Basic Usage](/agents/python/basic-usage) for fetching and executing tools
* [Tool Search](/agents/python/tool-search) for search patterns
* [LangChain Integration](/agents/python/frameworks/langchain-integration) for framework integration