Scientific - Medical Q&A

1
import requests
2
import uuid
3
import json
4
5
headers = {
6
    "Authorization": f"Bearer {API_KEY}",
7
    "X-Organization-ID": ORG_ID,
8
    "Content-Type": "application/json",
9
    "Idempotency-Key": str(uuid.uuid4())
10
}
11
12
response = requests.post(
13
    f"{BASE_URL}/v2/datasets/scientific/medical/ask",
14
    headers=headers,
15
    json={
16
        "question": "What is the evidence that BRCA1-mutated breast cancer patients benefit from PARP inhibitors?",
17
        "max_sources": 10,
18
        "include_trials": True,
19
        "recency_years": 10
20
    },
21
    timeout=180.0,
22
)
23
24
# Surface non-JSON responses (504 gateway timeout, 502 bad gateway, empty body,
25
# HTML error pages) instead of blowing up with an opaque JSONDecodeError.
26
if response.headers.get("content-type", "").startswith("application/json"):
27
    print(json.dumps(response.json(), indent=2))
28
else:
29
    print(f"HTTP {response.status_code}  content-type={response.headers.get('content-type')!r}")
30
    print(f"body: {response.text[:500]!r}")

1
const controller = new AbortController();
2
const timeoutId = setTimeout(() => controller.abort(), 180_000);
3
4
const response = await fetch(
5
  `${BASE_URL}/v2/datasets/scientific/medical/ask`,
6
  {
7
    method: "POST",
8
    headers: {
9
      "Authorization": `Bearer ${API_KEY}`,
10
      "X-Organization-ID": ORG_ID,
11
      "Content-Type": "application/json",
12
      "Idempotency-Key": crypto.randomUUID()
13
    },
14
    body: JSON.stringify({
15
      question: "What is the evidence that BRCA1-mutated breast cancer patients benefit from PARP inhibitors?",
16
      max_sources: 10,
17
      include_trials: true,
18
      recency_years: 10
19
    }),
20
    signal: controller.signal
21
  }
22
);
23
clearTimeout(timeoutId);
24
25
// Surface non-JSON responses (504/502/empty body) instead of crashing.
26
const contentType = response.headers.get("content-type") || "";
27
if (!contentType.startsWith("application/json")) {
28
  const body = await response.text();
29
  console.log(`HTTP ${response.status}  content-type=${contentType}`);
30
  console.log(`body: ${body.slice(0, 500)}`);
31
} else {
32
  const result = await response.json();
33
  console.log(JSON.stringify(result, null, 2));
34
}

1
require 'securerandom'
2
3
uri = URI("#{BASE_URL}/v2/datasets/scientific/medical/ask")
4
http = Net::HTTP.new(uri.host, uri.port)
5
http.use_ssl = true
6
http.read_timeout = 180
7
8
request = Net::HTTP::Post.new(uri)
9
request["Authorization"] = "Bearer #{API_KEY}"
10
request["X-Organization-ID"] = ORG_ID
11
request["Content-Type"] = "application/json"
12
request["Idempotency-Key"] = SecureRandom.uuid
13
request.body = {
14
  question: "What is the evidence that BRCA1-mutated breast cancer patients benefit from PARP inhibitors?",
15
  max_sources: 10,
16
  include_trials: true,
17
  recency_years: 10
18
}.to_json
19
20
response = http.request(request)
21
content_type = response["content-type"] || ""
22
if content_type.start_with?("application/json")
23
  puts JSON.pretty_generate(JSON.parse(response.body))
24
else
25
  puts "HTTP #{response.code}  content-type=#{content_type}"
26
  puts "body: #{response.body[0, 500]}"
27
end

1
import json
2
import requests
3
4
response = requests.post(
5
    f"{BASE_URL}/v2/datasets/scientific/medical/ask",
6
    headers={
7
        "Authorization": f"Bearer {API_KEY}",
8
        "X-Organization-ID": ORG_ID,
9
        "Content-Type": "application/json"
10
    },
11
    json={
12
        "question": "What are the latest published outcomes for CAR-T therapy in multiple myeloma?",
13
        "stream": True
14
    },
15
    stream=True  # Important: enable streaming
16
)
17
18
# Process streamed response
19
for line in response.iter_lines():
20
    if line:
21
        line_text = line.decode('utf-8')
22
        if line_text.startswith('data: '):
23
            data = line_text[6:]
24
            try:
25
                parsed = json.loads(data)
26
                if parsed.get('type') == 'tool.start':
27
                    print(f"\n[tool] {parsed['name']}: {parsed['args']}")
28
                elif parsed.get('type') == 'text.delta':
29
                    print(parsed['data'], end='', flush=True)
30
                elif parsed.get('type') == 'stream_complete':
31
                    print("\nStream complete!")
32
                    break
33
            except json.JSONDecodeError:
34
                print(data, end='', flush=True)

1
const response = await fetch(
2
  `${BASE_URL}/v2/datasets/scientific/medical/ask`,
3
  {
4
    method: "POST",
5
    headers: {
6
      "Authorization": `Bearer ${API_KEY}`,
7
      "X-Organization-ID": ORG_ID,
8
      "Content-Type": "application/json"
9
    },
10
    body: JSON.stringify({
11
      question: "What are the latest published outcomes for CAR-T therapy in multiple myeloma?",
12
      stream: true
13
    })
14
  }
15
);
16
17
// Process streamed response
18
const reader = response.body!.getReader();
19
const decoder = new TextDecoder();
20
21
while (true) {
22
  const { done, value } = await reader.read();
23
  if (done) break;
24
25
  const chunk = decoder.decode(value);
26
  const lines = chunk.split('\n');
27
28
  for (const line of lines) {
29
    if (line.startsWith('data: ')) {
30
      const data = line.slice(6);
31
      try {
32
        const parsed = JSON.parse(data);
33
        if (parsed.type === 'tool.start') {
34
          console.log(`\n[tool] ${parsed.name}:`, parsed.args);
35
        } else if (parsed.type === 'text.delta') {
36
          process.stdout.write(parsed.data);
37
        } else if (parsed.type === 'stream_complete') {
38
          console.log("\nStream complete!");
39
          break;
40
        }
41
      } catch {
42
        process.stdout.write(data);
43
      }
44
    }
45
  }
46
}

1
uri = URI("#{BASE_URL}/v2/datasets/scientific/medical/ask")
2
http = Net::HTTP.new(uri.host, uri.port)
3
http.use_ssl = true
4
5
request = Net::HTTP::Post.new(uri)
6
request["Authorization"] = "Bearer #{API_KEY}"
7
request["X-Organization-ID"] = ORG_ID
8
request["Content-Type"] = "application/json"
9
request.body = {
10
  question: "What are the latest published outcomes for CAR-T therapy in multiple myeloma?",
11
  stream: true
12
}.to_json
13
14
# Process streamed response
15
http.request(request) do |response|
16
  response.read_body do |chunk|
17
    chunk.each_line do |line|
18
      if line.start_with?("data: ")
19
        data = line[6..-1].strip
20
        begin
21
          parsed = JSON.parse(data)
22
          case parsed["type"]
23
          when "tool.start"       then puts "\n[tool] #{parsed['name']}: #{parsed['args']}"
24
          when "text.delta"       then print parsed["data"]
25
          when "stream_complete"
26
            puts "\nStream complete!"
27
            break
28
          end
29
        rescue JSON::ParserError
30
          print data
31
        end
32
      end
33
    end
34
  end
35
end