The way to Use OpenAI’s Responses API & Agent SDK?

OpenAI has been a number one options supplier within the GenAI house. From the legendary ChatGPT to Sora, it’s a go-to platform for all of the working professionals on the market. With Qwen and Claude gaining recognition amongst builders, OpenAI is again once more with its newest updates, empowering builders to create extra dependable and succesful AI brokers. The main highlights from the record embrace the Responses API and Brokers SDK. On this weblog, we are going to discover the Responses API and Brokers SDK, perceive methods to entry them, and discover ways to use them to construct real-world purposes!

What’s the Responses API?

The Responses API is OpenAI’s latest API designed for simplifying the method of constructing AI-based purposes. It combines the simplicity of the Chat Completions API with the highly effective tool-use capabilities of the Assistants API. This implies builders can now create brokers that leverage a number of instruments and deal with advanced, multi-step duties extra effectively. This API diminished the reliance on advanced immediate engineering and exterior integrations.  

Key Options of the Responses API

• Constructed-in instruments like internet search, file search, and laptop use, permitting brokers to work together with real-world knowledge.
• Unified design that simplifies polymorphism and improves usability.
• Higher observability, serving to builders observe agent habits and optimize workflows.
• No further prices, as it’s charged based mostly on token utilization at OpenAI’s commonplace pricing.

With these instruments, Responses API is a recreation changer in the direction of constructing AI brokers. Infact, going ahead, Responses API will assist all of OpenAI’s new and upcoming fashions. Let’s see how we are able to use it to construct purposes.

The way to use Responses API?

To attempt Responses API:

1. Set up openai (if not already put in) and use OpenAI.
2. Guarantee you will have the newest OpenAI library(pip set up openai – -upgrade).
3. Import OpenAI and Set Up the Shopper.

As soon as arrange, you may request the Responses API. Whereas primary API calls are widespread, its built-in capabilities make it highly effective. Let’s discover three key options:

• File Search: Retrieve insights from paperwork.
• Internet Search: Get real-time, cited info.
• Laptop Use: Automate system interactions.

Now, let’s see them in motion!

1. File Search

It permits fashions to retrieve info in a data base of beforehand uploaded information by way of semantic and key phrase search. At present it doesn’t assist csv information, you may examine the record of supported file varieties right here.

Observe: Earlier than utilizing the file search, be certain to retailer your information in a vector database

Process: Names of individuals with area as Information Science. (I used the next File.)

Code:

response = consumer.responses.create(

    mannequin="gpt-4o-mini",

    enter="Names of individuals with area as Information Science",

    instruments=[{

        "type": "file_search",

        "vector_store_ids": [vector_store_id],

        "filters": {

            "kind": "eq",

            "key": "Area",

            "worth": "Information Science"

        }

    }]

)

print(response.output_text)

Output:

The particular person with the area of Information Science is Alice Johnson [0].
[0] names_and_domains.pdf

2. Internet Search

This function permits fashions to look the net for the newest info earlier than producing a response, making certain that the info stays updated. The mannequin can select to look the net or not based mostly on the content material of the enter immediate.

Process : What are the perfect cafes in Vijay nagar?

Code:

response = consumer.responses.create(

    mannequin="gpt-4o",

    instruments=[{

        "type": "web_search_preview",

        "user_location": {

            "type": "approximate",

            "country": "IN",

            "city": "Indore",

            "region": "Madhya Pradesh",

        }

    }],

    enter="What are the perfect cafe in Vijay nagar?",

)

print(response.output_text)

Output:

3. Laptop Use

It’s a sensible software of Laptop-using Agent(CUA) Mannequin, which mixes the imaginative and prescient capabilities of GPT-4o with superior reasoning to simulate controlling laptop interfaces and carry out duties.

Process: Verify the newest weblog on Analytics Vidhya web site.

Code:

response = consumer.responses.create(

    mannequin="computer-use-preview",

    instruments=[{

        "type": "computer_use_preview",

        "display_width": 1024,

        "display_height": 768,

        "environment": "browser" # other possible values: "mac", "windows", "ubuntu"

    }],

    enter=[

        {

            "role": "user",

            "content": "Check the latest blog on Analytics Vidhya website."

        }

    ],

    truncation="auto"

)

print(response.output)

Output:

ResponseComputerToolCall(id='cu_67d147af346c8192b78719dd0e22856964fbb87c6a42e96', 
motion=ActionScreenshot(kind="screenshot"), 
call_id='call_a0w16G1BNEk09aYIV25vdkxY', pending_safety_checks=[], 
standing="accomplished", kind="computer_call")

How is the Responses API Totally different from the Completions API?

Now that now we have seen how the Responses API works, let’s see how totally different it’s from the pre-existing Completions API.

Responses API vs Completions API: Execution

API	Responses API	Completions API
Code	from openai import OpenAI consumer = OpenAI() response = consumer.responses.create( mannequin="gpt-4o", inputs=[ { "role": "user", "content": "Write a one-sentence bedtime story about a unicorn." } ] ) print(response.output_text)	from openai import OpenAI consumer = OpenAI() completion = consumer.chat.completions.create( mannequin="gpt-4o", messages=[ { "role": "user", "content": "Write a one-sentence bedtime story about a unicorn." } ] ) print(completion.decisions[0].message.content material)
Output

Responses API vs Completions API: Options

Here’s a simplified breakdown of the varied options of Chat Complerions APi and Responses API:

Roadmap: What Will Proceed, What Will Deprecate?

With Responses API going dwell, the burning query now could be, would it not have an effect on the prevailing Chat Completions and Assistant API? Sure it might. Let’s take a look at how:

• Chat Completions API: OpenAI will proceed updating it with new fashions, however solely when the capabilities don’t require built-in instruments.
• Internet Search & File Search Instruments: These will grow to be extra refined and highly effective within the Responses API.
• Assistants API: The Responses API incorporates its finest options whereas enhancing efficiency. OpenAI has introduced that full function parity is coming quickly, and the Assistants API will probably be deprecated by mid-2026.

Introducing the Brokers SDK

Constructing AI brokers isn’t just about having a robust API—it requires environment friendly orchestration. That is the place OpenAI’s Brokers SDK comes into play. The Brokers SDK is an open-source toolkit that simplifies agent workflows. This agent constructing framework integrates seamlessly with the Responses API and Chat Completions API. Moreover, additionally it is appropriate with fashions from varied suppliers, offered they provide an API endpoint styled like Chat Completions.

Among the key options of Brokers SDK are:

• It permits builders to configure AI brokers with built-in instruments.
• It permits multi-agent orchestration, permitting seamless coordination of various brokers as wanted.
• It permits us to trace the dialog & the stream of knowledge between our brokers.
• It permits a better solution to apply guardrails for security and compliance.
• It ensures that builders can monitor and optimize agent efficiency with built-in observability instruments.

Agent SDK isn’t a “new addition” to OpenAI’s jewels. It’s an improved model of “Swarm”, the experimental SDK that OpenAI had launched final yr. Whereas “Swarm” was simply launched for academic functions, it grew to become standard amongst builders and was adopted by a number of enterprises too. To cater to extra enterprises and assist them construct production-grade brokers seamlessly, Brokers SDK has been launched. Now that we all know what Brokers SDK has to supply, let’s see how we are able to use this framework to construct our agentic system.

Additionally Learn: High 10 Generative AI Coding Extensions in VS Code

Construct a Multi-agentic System utilizing Agent SDK

We are going to construct a multi-agent system that helps customers with automobile suggestions and resale worth estimation by leveraging LLM-powered brokers and internet search instruments to supply correct and up-to-date insights.

Step 1: Constructing a Easy AI Agent

We start by making a Automobile Advisor Agent that helps customers select an appropriate automobile kind based mostly on their wants.

Code:

car_advisor = Agent(

    identify="Automobile advisor",

    directions= "You're an knowledgeable in advising appropriate automobile kind like sedan, hatchback and so on to individuals based mostly on their necessities.",

    mannequin="gpt-4o",

    )

immediate = "I'm searching for a automobile that I get pleasure from driving and comforatbly take 4 individuals. I airplane to journey to hills. What kind of automobile ought to I purchase?"

async def predominant():

    end result = await Runner.run(car_advisor, immediate)

    print(end result.final_output)

# Run the operate in Jupyter

await predominant()

Output:

Step 2: Construct the Multi-Agent System

With the fundamental agent in place, we now create a multi-agent system incorporating totally different AI brokers specialised of their respective domains. Right here’s the way it works:

Brokers within the Multi-Agent System

1. Automobile Promote Estimate Agent: It gives a resale worth estimate based mostly on automobile particulars.
2. Automobile Mannequin Advisor Agent: It suggests appropriate automobile fashions based mostly on funds and site.
3. Triage Agent: It directs the question to the suitable agent.

We are going to present two totally different prompts to the brokers and observe their outputs.

Code:

car_sell_estimate = Agent(

    identify="Automobile promote estimate",

    directions= "You're an knowledgeable in suggesting an appropriate worth of reselling a automobile based mostly on its make, mannequin, yr of buy, and situation.",

    handoff_description= "Automobile reselling worth estimate knowledgeable",

    mannequin="gpt-4o",

    instruments=[WebSearchTool()]

    )

car_model_advisor = Agent(

    identify="Automobile mannequin advisor",

    directions= "You're an knowledgeable in advising appropriate automobile mannequin to individuals based mostly on their funds and site.",

    handoff_description= "Automobile mannequin suggestion knowledgeable",

    mannequin="gpt-4o",

    instruments=[WebSearchTool()]

    )

triage_agent = Agent(

    identify = "Triage Agent",

    directions="You establish the suitable agent for the duty.",

    mannequin = "gpt-4o",

    handoffs=[car_sell_estimate, car_model_advisor]

)

Immediate 1: 

immediate = "I wish to promote my Ecosport automobile in New Delhi. It's 3 years previous and in good situation. 50000Km. What worth ought to I count on?"

async def predominant():

    end result = await Runner.run(triage_agent, immediate)

    print(end result.final_output)

# Run the operate in Jupyter

await predominant()

Output 1:

Immediate 2:

immediate = "I wish to purchase a excessive acceleration automobile, comfy for 4 individuals for 20 lakhs in New Delhi. Which automobile ought to I purchase?"

async def predominant():

    end result = await Runner.run(triage_agent, immediate)

    print(end result.final_output)

# Run the operate in Jupyter

await predominant()

Output 2:

We acquired the automobile choices as per our necessities! The implementation was easy and fast. You should utilize this agentic framework to construct brokers for journey assist, monetary planning, medical help, customized buying, automated analysis, and rather more.

Agent’s SDK: A New Agentic Framework in City?

OpenAI’s Brokers SDK represents its strategic push towards offering a devoted framework for AI agent improvement. The framework contains crew-like options by way of its triage agent, mimicking Crew AI’s options. Equally, its handoff mechanisms carefully resemble these of AutoGen, permitting environment friendly delegation of duties amongst a number of brokers.

Moreover, LangChain’s energy in modular agent orchestration is mirrored in the way in which the Brokers SDK gives structured workflows, making certain clean execution and adaptableness. Whereas Brokers SDK presents nothing greater than what the prevailing frameworks already do, it quickly will give them a troublesome competitors. 

Additionally Learn: Claude 3.7 Sonnet: The Greatest Coding Mannequin But?

Why Do Builders Want Responses API & Brokers SDK?

Responses API and Brokers SDK present builders with the instruments & platform to construct AI-driven purposes. By decreasing the reliance on handbook immediate engineering and in depth customized logic, these instruments permit builders to deal with creating clever workflows with minimal friction.

• Straightforward Integration: Builders not must juggle a number of APIs for various instruments; the Responses API consolidates internet search, file search, and laptop use right into a single interface.
• Higher Observability: With built-in monitoring and debugging instruments, builders can optimize agent efficiency extra simply.
• Scalability: The Brokers SDK gives a structured strategy to dealing with multi-agent workflows, enabling extra sturdy automation.
• Improved Growth Cycles: By eliminating the necessity for in depth immediate iteration and exterior software integration, builders can prototype and deploy agent-based purposes at a a lot quicker tempo.

Conclusion

The introduction of OpenAI’s Responses API and Brokers SDK is a game-changer for AI-driven automation. By leveraging these instruments, we efficiently constructed a multi-agent system in a short time with only a few traces of code. This implementation might be additional expanded to incorporate further instruments, integrations, and agent capabilities, paving the way in which for extra clever and autonomous AI purposes in varied industries.

These instruments are absolutely going to assist builders and enterprises cut back improvement complexity, and create smarter, extra scalable automation options. Whether or not it’s for buyer assist, analysis, enterprise automation, or industry-specific AI purposes, the Responses API and Brokers SDK supply a robust framework to construct next-generation AI-powered programs with ease.

Regularly Requested Questions

Anu Madan has 5+ years of expertise in content material creation and administration. Having labored as a content material creator, reviewer, and supervisor, she has created a number of programs and blogs. At present, she engaged on creating and strategizing the content material curation and design round Generative AI and different upcoming expertise.