deep research

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34import OpenAI from "openai";
const openai = new OpenAI({ timeout: 3600 * 1000 });

const input = `
Research the economic impact of semaglutide on global healthcare systems.
Do:
- Include specific figures, trends, statistics, and measurable outcomes.
- Prioritize reliable, up-to-date sources: peer-reviewed research, health
  organizations (e.g., WHO, CDC), regulatory agencies, or pharmaceutical
  earnings reports.
- Include inline citations and return all source metadata.

Be analytical, avoid generalities, and ensure that each section supports
data-backed reasoning that could inform healthcare policy or financial modeling.
`;

const response = await openai.responses.create({
  model: "o3-deep-research",
  input,
  background: true,
  tools: [
    { type: "web_search_preview" },
    {
      type: "file_search",
      vector_store_ids: [
        "vs_68870b8868b88191894165101435eef6",
        "vs_12345abcde6789fghijk101112131415",
      ],
    },
    { type: "code_interpreter", container: { type: "auto" } },
  ],
});

console.log(response);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

const researchInput = `
Research the economic impact of semaglutide on global healthcare systems.
Do:
- Include specific figures, trends, statistics, and measurable outcomes.
- Prioritize reliable, up-to-date sources: peer-reviewed research, health organizations (e.g., WHO, CDC), regulatory agencies, or pharmaceutical earnings reports.
- Include inline citations and return all source metadata.

Be analytical, avoid generalities, and ensure that each section supports data-backed reasoning that could inform healthcare policy or financial modeling.
`

func main() {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:      "o3-deep-research",
		Background: openai.Bool(true),
		Input:      responses.ResponseNewParamsInputUnion{OfString: openai.String(researchInput)},
		Tools: []responses.ToolUnionParam{
			responses.ToolParamOfWebSearchPreview(responses.WebSearchPreviewToolTypeWebSearchPreview),
			responses.ToolParamOfFileSearch([]string{"vs_68870b8868b88191894165101435eef6", "vs_12345abcde6789fghijk101112131415"}),
			responses.ToolParamOfCodeInterpreter(responses.ToolCodeInterpreterContainerCodeInterpreterContainerAutoParam{}),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseStatus;
import com.openai.models.responses.Tool;
import com.openai.models.responses.WebSearchTool;
import java.util.List;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("o3-deep-research")
        .input(
            "Research the economic impact of semaglutide on global healthcare systems. Include measurable outcomes and cite primary sources.")
        .background(true)
        .addTool(WebSearchTool.builder().type(WebSearchTool.Type.WEB_SEARCH).build())
        .addFileSearchTool(List.of(System.getenv("OPENAI_EXAMPLE_VECTOR_STORE_ID")))
        .addCodeInterpreterTool(
            Tool.CodeInterpreter.Container.CodeInterpreterToolAuto.builder().build())
        .build();

var response = client.responses().create(params);
while (response.status().filter(ResponseStatus.QUEUED::equals).isPresent()
    || response.status().filter(ResponseStatus.IN_PROGRESS::equals).isPresent()) {
  Thread.sleep(1000);
  response = client.responses().retrieve(response.id());
}
if (response.status().filter(ResponseStatus.COMPLETED::equals).isEmpty()) {
  throw new IllegalStateException(
      "Research ended with status: " + response.status().orElseThrow());
}

response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CodeInterpreterToolContainer container = new(
    CodeInterpreterToolContainerConfiguration.CreateAutomaticContainerConfiguration([])
);
CreateResponseOptions options = new()
{
    Model = "o3-deep-research",
    BackgroundModeEnabled = true,
};
options.Tools.Add(ResponseTool.CreateWebSearchPreviewTool());
// Replace this illustrative value with your research data source.
string vectorStoreId = "vs_123";
options.Tools.Add(ResponseTool.CreateFileSearchTool([vectorStoreId]));
options.Tools.Add(ResponseTool.CreateCodeInterpreterTool(container));
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem(
        """
        Research the economic impact of semaglutide on global healthcare systems.
        Do:
        - Include specific figures, trends, statistics, and measurable outcomes.
        - Prioritize reliable, up-to-date sources: peer-reviewed research, health
          organizations (e.g., WHO, CDC), regulatory agencies, or pharmaceutical
          earnings reports.
        - Include inline citations and return all source metadata.

        Be analytical, avoid generalities, and ensure that each section supports
        data-backed reasoning that could inform healthcare policy or financial modeling.
        """
    )
);

ResponseResult response = await client.CreateResponseAsync(options);
while (response.Status is ResponseStatus.Queued or ResponseStatus.InProgress)
{
    await Task.Delay(TimeSpan.FromSeconds(1));
    response = await client.GetResponseAsync(response.Id);
}
if (response.Status != ResponseStatus.Completed)
{
    throw new InvalidOperationException($"Research ended with status: {response.Status}");
}
Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34# Replace the illustrative IDs and URLs below with your own resource values.
require "openai"

client = OpenAI::Client.new
vector_store_id = "vs_123"
response = client.responses.create(
  model: "o3-deep-research",
  input: "Research the economic impact of semaglutide on global healthcare systems. Include measurable outcomes and cite primary sources.",
  tools: [
    { type: :web_search_preview },
    {
      type: :file_search,
      vector_store_ids: [vector_store_id]
    },
    {
      type: :code_interpreter,
      container: { type: :auto }
    }
  ],
  background: true
)

while [
  OpenAI::Responses::ResponseStatus::QUEUED,
  OpenAI::Responses::ResponseStatus::IN_PROGRESS
].include?(response.status)
  sleep(2)
  response = client.responses.retrieve(response.id)
end
unless response.status == OpenAI::Responses::ResponseStatus::COMPLETED
  raise "Research ended with status: #{response.status}"
end

puts(response.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16curl https://api.openai.com/v1/responses   -H "Authorization: Bearer $OPENAI_API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "o3-deep-research",
    "input": "Research the economic impact of semaglutide on global healthcare systems. Include specific figures, trends, statistics, and measurable outcomes. Prioritize reliable, up-to-date sources: peer-reviewed research, health organizations (e.g., WHO, CDC), regulatory agencies, or pharmaceutical earnings reports. Include inline citations and return all source metadata. Be analytical, avoid generalities, and ensure that each section supports data-backed reasoning that could inform healthcare policy or financial modeling.",
    "background": true,
    "tools": [
      { "type": "web_search_preview" },
      {
        "type": "file_search",
        "vector_store_ids": [
          "vs_68870b8868b88191894165101435eef6",
          "vs_12345abcde6789fghijk101112131415"
        ]
      },
      { "type": "code_interpreter", "container": { "type": "auto" } }
    ]
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import OpenAI from "openai";
const openai = new OpenAI();

const instructions = `
You are talking to a user who is asking for a research task to be conducted. Your job is to gather more information from the user to successfully complete the task.

GUIDELINES:
- Be concise while gathering all necessary information**
- Make sure to gather all the information needed to carry out the research task in a concise, well-structured manner.
- Use bullet points or numbered lists if appropriate for clarity.
- Don't ask for unnecessary information, or information that the user has already provided.

IMPORTANT: Do NOT conduct any research yourself, just gather information that will be given to a researcher to conduct the research task.
`;

const input = "Research surfboards for me. I'm interested in ...";

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input,
  instructions,
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

const instructions = `
You are talking to a user who is asking for a research task to be conducted. Your job is to gather more information from the user to successfully complete the task.

GUIDELINES:
- Be concise while gathering all necessary information.
- Make sure to gather all the information needed to carry out the research task in a concise, well-structured manner.
- Use bullet points or numbered lists if appropriate for clarity.
- Don't ask for unnecessary information, or information that the user has already provided.

IMPORTANT: Do NOT conduct any research yourself, just gather information that will be given to a researcher to conduct the research task.
`

func main() {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:        "gpt-6-astra",
		Instructions: openai.String(instructions),
		Input:        responses.ResponseNewParamsInputUnion{OfString: openai.String("Research surfboards for me. I'm interested in ...")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Research surfboards for me. I'm interested in ...")
        .instructions(
            "Ask concise questions to gather all missing requirements. Do not conduct the research yet.")
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    Instructions =
        """
        You are talking to a user who is asking for a research task to be conducted.
        Your job is to gather more information to successfully complete the task.

        GUIDELINES:
        - Gather all necessary information concisely and in a well-structured manner.
        - Use bullet points or numbered lists when they improve clarity.
        - Do not ask for unnecessary information or repeat details the user already provided.

        IMPORTANT: Do NOT conduct any research yourself. Gather information that a
        researcher will use to complete the task.
        """,
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Research surfboards for me.")
);

ResponseResult response = await client.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  instructions: "Ask concise questions to gather all missing requirements. Do not conduct the research yet.",
  input: "Research surfboards for me. I'm interested in ..."
)

puts(response.output_text)

1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "model": "gpt-6-astra",
  "input": "Research surfboards for me. Im interested in ...",
  "instructions": "You are talking to a user who is asking for a research task to be conducted. Your job is to gather more information from the user to successfully complete the task. GUIDELINES: - Be concise while gathering all necessary information** - Make sure to gather all the information needed to carry out the research task in a concise, well-structured manner. - Use bullet points or numbered lists if appropriate for clarity. - Don't ask for unnecessary information, or information that the user has already provided. IMPORTANT: Do NOT conduct any research yourself, just gather information that will be given to a researcher to conduct the research task."
}'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78import OpenAI from "openai";
const openai = new OpenAI();

const instructions = `
You will be given a research task by a user. Your job is to produce a set of
instructions for a researcher that will complete the task. Do NOT complete the
task yourself, just provide instructions on how to complete it.

GUIDELINES:
1. **Maximize Specificity and Detail**
- Include all known user preferences and explicitly list key attributes or
  dimensions to consider.
- It is of utmost importance that all details from the user are included in
  the instructions.

2. **Fill in Unstated But Necessary Dimensions as Open-Ended**
- If certain attributes are essential for a meaningful output but the user
  has not provided them, explicitly state that they are open-ended or default
  to no specific constraint.

3. **Avoid Unwarranted Assumptions**
- If the user has not provided a particular detail, do not invent one.
- Instead, state the lack of specification and guide the researcher to treat
  it as flexible or accept all possible options.

4. **Use the First Person**
- Phrase the request from the perspective of the user.

5. **Tables**
- If you determine that including a table will help illustrate, organize, or
  enhance the information in the research output, you must explicitly request
  that the researcher provide them.

Examples:
- Product Comparison (Consumer): When comparing different smartphone models,
  request a table listing each model's features, price, and consumer ratings
  side-by-side.
- Project Tracking (Work): When outlining project deliverables, create a table
  showing tasks, deadlines, responsible team members, and status updates.
- Budget Planning (Consumer): When creating a personal or household budget,
  request a table detailing income sources, monthly expenses, and savings goals.
- Competitor Analysis (Work): When evaluating competitor products, request a
  table with key metrics, such as market share, pricing, and main differentiators.

6. **Headers and Formatting**
- You should include the expected output format in the prompt.
- If the user is asking for content that would be best returned in a
  structured format (e.g. a report, plan, etc.), ask the researcher to format
  as a report with the appropriate headers and formatting that ensures clarity
  and structure.

7. **Language**
- If the user input is in a language other than English, tell the researcher
  to respond in this language, unless the user query explicitly asks for the
  response in a different language.

8. **Sources**
- If specific sources should be prioritized, specify them in the prompt.
- For product and travel research, prefer linking directly to official or
  primary websites (e.g., official brand sites, manufacturer pages, or
  reputable e-commerce platforms like Amazon for user reviews) rather than
  aggregator sites or SEO-heavy blogs.
- For academic or scientific queries, prefer linking directly to the original
  paper or official journal publication rather than survey papers or secondary
  summaries.
- If the query is in a specific language, prioritize sources published in that
  language.
`;

const input = "Research surfboards for me. I'm interested in ...";

const response = await openai.responses.create({
  model: "gpt-6-astra",
  input,
  instructions,
});

console.log(response.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

const instructions = `
You will be given a research task by a user. Your job is to produce a set of
instructions for a researcher that will complete the task. Do NOT complete the
task yourself, just provide instructions on how to complete it.

GUIDELINES:
1. **Maximize Specificity and Detail**
- Include all known user preferences and explicitly list key attributes or
  dimensions to consider.
- It is of utmost importance that all details from the user are included in
  the instructions.

2. **Fill in Unstated But Necessary Dimensions as Open-Ended**
- If certain attributes are essential for a meaningful output but the user
  has not provided them, explicitly state that they are open-ended or default
  to no specific constraint.

3. **Avoid Unwarranted Assumptions**
- If the user has not provided a particular detail, do not invent one.
- Instead, state the lack of specification and guide the researcher to treat
  it as flexible or accept all possible options.

4. **Use the First Person**
- Phrase the request from the perspective of the user.

5. **Tables**
- If you determine that including a table will help illustrate, organize, or
  enhance the information in the research output, you must explicitly request
  that the researcher provide them.

Examples:
- Product Comparison (Consumer): When comparing different smartphone models,
  request a table listing each model's features, price, and consumer ratings
  side-by-side.
- Project Tracking (Work): When outlining project deliverables, create a table
  showing tasks, deadlines, responsible team members, and status updates.
- Budget Planning (Consumer): When creating a personal or household budget,
  request a table detailing income sources, monthly expenses, and savings goals.
- Competitor Analysis (Work): When evaluating competitor products, request a
  table with key metrics, such as market share, pricing, and main differentiators.

6. **Headers and Formatting**
- You should include the expected output format in the prompt.
- If the user is asking for content that would be best returned in a
  structured format (e.g. a report, plan, etc.), ask the researcher to format
  as a report with the appropriate headers and formatting that ensures clarity
  and structure.

7. **Language**
- If the user input is in a language other than English, tell the researcher
  to respond in this language, unless the user query explicitly asks for the
  response in a different language.

8. **Sources**
- If specific sources should be prioritized, specify them in the prompt.
- For product and travel research, prefer linking directly to official or
  primary websites (e.g., official brand sites, manufacturer pages, or
  reputable e-commerce platforms like Amazon for user reviews) rather than
  aggregator sites or SEO-heavy blogs.
- For academic or scientific queries, prefer linking directly to the original
  paper or official journal publication rather than survey papers or secondary
  summaries.
- If the query is in a specific language, prioritize sources published in that
  language.
`

func main() {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:        "gpt-6-astra",
		Instructions: openai.String(instructions),
		Input:        responses.ResponseNewParamsInputUnion{OfString: openai.String("Research surfboards for me. I'm interested in ...")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

String researchInstructions =
    """
    You will be given a research task by a user. Your job is to produce a set of
    instructions for a researcher that will complete the task. Do NOT complete the
    task yourself, just provide instructions on how to complete it.

    GUIDELINES:
    1. **Maximize Specificity and Detail**
    - Include all known user preferences and explicitly list key attributes or
      dimensions to consider.
    - It is of utmost importance that all details from the user are included in
      the instructions.

    2. **Fill in Unstated But Necessary Dimensions as Open-Ended**
    - If certain attributes are essential for a meaningful output but the user
      has not provided them, explicitly state that they are open-ended or default
      to no specific constraint.

    3. **Avoid Unwarranted Assumptions**
    - If the user has not provided a particular detail, do not invent one.
    - Instead, state the lack of specification and guide the researcher to treat
      it as flexible or accept all possible options.

    4. **Use the First Person**
    - Phrase the request from the perspective of the user.

    5. **Tables**
    - If you determine that including a table will help illustrate, organize, or
      enhance the information in the research output, you must explicitly request
      that the researcher provide them.

    Examples:
    - Product Comparison (Consumer): When comparing different smartphone models,
      request a table listing each model's features, price, and consumer ratings
      side-by-side.
    - Project Tracking (Work): When outlining project deliverables, create a table
      showing tasks, deadlines, responsible team members, and status updates.
    - Budget Planning (Consumer): When creating a personal or household budget,
      request a table detailing income sources, monthly expenses, and savings goals.
    - Competitor Analysis (Work): When evaluating competitor products, request a
      table with key metrics, such as market share, pricing, and main differentiators.

    6. **Headers and Formatting**
    - You should include the expected output format in the prompt.
    - If the user is asking for content that would be best returned in a
      structured format (e.g. a report, plan, etc.), ask the researcher to format
      as a report with the appropriate headers and formatting that ensures clarity
      and structure.

    7. **Language**
    - If the user input is in a language other than English, tell the researcher
      to respond in this language, unless the user query explicitly asks for the
      response in a different language.

    8. **Sources**
    - If specific sources should be prioritized, specify them in the prompt.
    - For product and travel research, prefer linking directly to official or
      primary websites (e.g., official brand sites, manufacturer pages, or
      reputable e-commerce platforms like Amazon for user reviews) rather than
      aggregator sites or SEO-heavy blogs.
    - For academic or scientific queries, prefer linking directly to the original
      paper or official journal publication rather than survey papers or secondary
      summaries.
    - If the query is in a specific language, prioritize sources published in that
      language.
    """;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Research surfboards for me. I'm interested in ...")
        .instructions(researchInstructions)
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "gpt-6-astra",
    Instructions =
        """
        You will receive a research task from a user. Produce instructions for the
        researcher who will complete it. Do NOT conduct the research yourself.

        GUIDELINES:
        1. Maximize specificity and detail. Include every stated preference and all
           attributes or dimensions the user identifies.
        2. Treat unstated but necessary dimensions as open-ended. Do not assume an
           unstated preference or invent details the user did not provide.
        3. Phrase the research request in the first person, from the user's perspective.
        4. Request tables whenever they clarify comparisons, project tracking, budgets,
           competitive analysis, or other structured information.
        5. Describe the expected output format, including report headers and other
           formatting needed to keep the research clear and well organized.
        6. Respond in the user's language unless they explicitly request another one.
        7. Prioritize reliable primary sources. Prefer official brand or manufacturer
           websites for products, original papers and journals for scientific questions,
           and sources published in the language of the user's request.
        """,
};
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem("Research surfboards for me.")
);

ResponseResult response = await client.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-6-astra",
  instructions: "Rewrite the user's request as detailed research instructions. Preserve all stated preferences, identify open-ended dimensions, request primary sources, and specify a clear report format. Do not perform the research.",
  input: "Research surfboards for me. I'm interested in ..."
)

puts(response.output_text)

1
2
3
4
5
6
7
8curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Research surfboards for me. Im interested in ...",
    "instructions": "You are a helpful assistant that generates a prompt for a deep research task. Examine the users prompt and generate a set of clarifying questions that will help the deep research model generate a better response."
  }'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import OpenAI from "openai";
const client = new OpenAI();

const instructions = "<deep research instructions...>";

const resp = await client.responses.create({
  model: "o3-deep-research",
  background: true,
  reasoning: {
    summary: "auto",
  },
  tools: [
    {
      type: "mcp",
      server_label: "mycompany_mcp_server",
      server_url: "https://mycompany.com/mcp",
      require_approval: "never",
    },
  ],
  instructions,
  input:
    "What similarities are in the notes for our closed/lost Salesforce opportunities?",
});

console.log(resp.output_text);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25from openai import OpenAI

client = OpenAI()

instructions = "<deep research instructions...>"

resp = client.responses.create(
    model="o3-deep-research",
    background=True,
    reasoning={
        "summary": "auto",
    },
    tools=[
        {
            "type": "mcp",
            "server_label": "mycompany_mcp_server",
            "server_url": "https://mycompany.com/mcp",
            "require_approval": "never",
        },
    ],
    instructions=instructions,
    input="What similarities are in the notes for our closed/lost Salesforce opportunities?",
)

print(resp.output_text)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
	"github.com/openai/openai-go/v3/shared"
)

func main() {
	client := openai.NewClient()
	tool := responses.ToolParamOfMcp("mycompany_mcp_server")
	tool.OfMcp.ServerURL = openai.String("https://mycompany.com/mcp")
	tool.OfMcp.RequireApproval = responses.ToolMcpRequireApprovalUnionParam{OfMcpToolApprovalSetting: openai.String("never")}
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:        "o3-deep-research",
		Background:   openai.Bool(true),
		Reasoning:    shared.ReasoningParam{Summary: shared.ReasoningSummaryAuto},
		Tools:        []responses.ToolUnionParam{tool},
		Instructions: openai.String("<deep research instructions...>"),
		Input:        responses.ResponseNewParamsInputUnion{OfString: openai.String("What similarities are in the notes for our closed/lost Salesforce opportunities?")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.OutputText())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39// Replace the illustrative IDs and URLs below with your own resource values.
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.Reasoning;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseStatus;
import com.openai.models.responses.Tool;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("o3-deep-research")
        .input("What patterns appear in our closed-lost Salesforce opportunities?")
        .instructions("Produce a source-backed deep research report.")
        .reasoning(Reasoning.builder().summary(Reasoning.Summary.AUTO).build())
        .background(true)
        .addTool(
            Tool.Mcp.builder()
                .serverLabel("mycompany_mcp_server")
                .serverUrl("https://mcp.example.com/mcp")
                .requireApproval(Tool.Mcp.RequireApproval.McpToolApprovalSetting.NEVER)
                .build())
        .build();

var response = client.responses().create(params);
while (response.status().filter(ResponseStatus.QUEUED::equals).isPresent()
    || response.status().filter(ResponseStatus.IN_PROGRESS::equals).isPresent()) {
  Thread.sleep(1000);
  response = client.responses().retrieve(response.id());
}
if (response.status().filter(ResponseStatus.COMPLETED::equals).isEmpty()) {
  throw new IllegalStateException(
      "Research ended with status: " + response.status().orElseThrow());
}

response.output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42using OpenAI.Responses;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ResponsesClient client = new(key);

CreateResponseOptions options = new()
{
    Model = "o3-deep-research",
    BackgroundModeEnabled = true,
    Instructions = "Analyze the Salesforce opportunity notes carefully.",
    ReasoningOptions = new ResponseReasoningOptions
    {
        ReasoningSummaryVerbosity = ResponseReasoningSummaryVerbosity.Auto,
    },
};
// Replace this illustrative value with your research data source.
string serverUrl = "https://mcp.example.com/mcp";
options.Tools.Add(
    ResponseTool.CreateMcpTool(
        "mycompany_mcp_server",
        new Uri(serverUrl),
        toolCallApprovalPolicy: DefaultMcpToolCallApprovalPolicy.NeverRequireApproval
    )
);
options.InputItems.Add(
    ResponseItem.CreateUserMessageItem(
        "What similarities appear in notes for closed or lost Salesforce opportunities?"
    )
);

ResponseResult response = await client.CreateResponseAsync(options);
while (response.Status is ResponseStatus.Queued or ResponseStatus.InProgress)
{
    await Task.Delay(TimeSpan.FromSeconds(1));
    response = await client.GetResponseAsync(response.Id);
}
if (response.Status != ResponseStatus.Completed)
{
    throw new InvalidOperationException($"Research ended with status: {response.Status}");
}
Console.WriteLine(response.GetOutputText());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33# Replace the illustrative IDs and URLs below with your own resource values.
require "openai"

client = OpenAI::Client.new
mcp_server_url = "https://mcp.example.com/mcp"
response = client.responses.create(
  model: "o3-deep-research",
  input: "What patterns appear in our closed-lost Salesforce opportunities?",
  instructions: "Produce a source-backed deep research report.",
  reasoning: { summary: :auto },
  tools: [
    {
      type: :mcp,
      server_label: "mycompany_mcp_server",
      server_url: mcp_server_url,
      require_approval: :never
    }
  ],
  background: true
)

while [
  OpenAI::Responses::ResponseStatus::QUEUED,
  OpenAI::Responses::ResponseStatus::IN_PROGRESS
].include?(response.status)
  sleep(2)
  response = client.responses.retrieve(response.id)
end
unless response.status == OpenAI::Responses::ResponseStatus::COMPLETED
  raise "Research ended with status: #{response.status}"
end

puts(response.output_text)