Fireworks

pip install openai requests
export FIREWORKS_API_KEY="your-fireworks-api-key"
export PARALLEL_API_KEY="your-parallel-api-key"

npm install openai
export FIREWORKS_API_KEY="your-fireworks-api-key"
export PARALLEL_API_KEY="your-parallel-api-key"

import json
import os
import uuid

import requests
from openai import OpenAI

MODEL = "accounts/fireworks/models/kimi-k3"

fireworks = OpenAI(
    api_key=os.environ["FIREWORKS_API_KEY"],
    base_url="https://api.fireworks.ai/inference/v1",
)

SEARCH_TOOL = {
    "type": "function",
    "function": {
        "name": "web_search",
        "description": "Search the web and return result titles, URLs, and excerpts.",
        "parameters": {
            "type": "object",
            "properties": {
                "objective": {
                    "type": "string",
                    "description": "Describe the search goal in a concise, standalone sentence. Name the key entity or topic.",
                },
                "search_queries": {
                    "type": "array",
                    "description": "Provide 1-3 keyword queries of 3-6 words each. Include the key entity or topic in every query. For multiple queries, vary names, synonyms, or angles. Do not use sentences, instructions, or site: operators.",
                    "items": {"type": "string"},
                    "minItems": 1,
                    "maxItems": 3,
                },
            },
            "required": ["objective", "search_queries"],
        },
    },
}

SYSTEM_PROMPT = (
    "Use the web_search tool to find current information before you answer. "
    "Answer in a few sentences, then end with a Sources list of the URLs you used."
)


def web_search(objective, search_queries, session_id):
    response = requests.post(
        "https://api.parallel.ai/v1/search",
        headers={"x-api-key": os.environ["PARALLEL_API_KEY"]},
        json={
            "objective": objective,
            "search_queries": search_queries,
            "session_id": session_id,
            "mode": "fast",
            "advanced_settings": {"max_results": 5},
        },
        timeout=60,
    )
    response.raise_for_status()
    return response.json()["results"]


def answer(question, max_steps=5):
    session_id = f"session_{uuid.uuid4().hex}"
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": question},
    ]
    for _ in range(max_steps):
        response = fireworks.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=[SEARCH_TOOL],
            temperature=0.1,
        )
        message = response.choices[0].message
        if not message.tool_calls:
            return message.content
        messages.append(message)
        for tool_call in message.tool_calls:
            args = json.loads(tool_call.function.arguments)
            results = web_search(args["objective"], args["search_queries"], session_id)
            messages.append(
                {
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": json.dumps(results),
                }
            )
    raise RuntimeError("The model did not finish answering within max_steps.")


if __name__ == "__main__":
    print(answer("What is the latest stable release of Python, and what is new in it?"))

import OpenAI from "openai";

const MODEL = "accounts/fireworks/models/kimi-k3";

const fireworks = new OpenAI({
  apiKey: process.env.FIREWORKS_API_KEY,
  baseURL: "https://api.fireworks.ai/inference/v1",
});

const searchTool: OpenAI.ChatCompletionTool = {
  type: "function",
  function: {
    name: "web_search",
    description: "Search the web and return result titles, URLs, and excerpts.",
    parameters: {
      type: "object",
      properties: {
        objective: {
          type: "string",
          description:
            "Describe the search goal in a concise, standalone sentence. Name the key entity or topic.",
        },
        search_queries: {
          type: "array",
          description:
            "Provide 1-3 keyword queries of 3-6 words each. Include the key entity or topic in every query. For multiple queries, vary names, synonyms, or angles. Do not use sentences, instructions, or site: operators.",
          items: { type: "string" },
          minItems: 1,
          maxItems: 3,
        },
      },
      required: ["objective", "search_queries"],
    },
  },
};

const SYSTEM_PROMPT =
  "Use the web_search tool to find current information before you answer. " +
  "Answer in a few sentences, then end with a Sources list of the URLs you used.";

async function webSearch(objective: string, searchQueries: string[], sessionId: string) {
  const response = await fetch("https://api.parallel.ai/v1/search", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": process.env.PARALLEL_API_KEY ?? "",
    },
    body: JSON.stringify({
      objective,
      search_queries: searchQueries,
      session_id: sessionId,
      mode: "fast",
      advanced_settings: { max_results: 5 },
    }),
  });
  if (!response.ok) {
    throw new Error(`Parallel Search failed: ${response.status} ${await response.text()}`);
  }
  const data = await response.json();
  return data.results;
}

async function answer(question: string, maxSteps = 5): Promise<string | null> {
  const sessionId = `session_${crypto.randomUUID()}`;
  const messages: OpenAI.ChatCompletionMessageParam[] = [
    { role: "system", content: SYSTEM_PROMPT },
    { role: "user", content: question },
  ];
  for (let step = 0; step < maxSteps; step++) {
    const response = await fireworks.chat.completions.create({
      model: MODEL,
      messages,
      tools: [searchTool],
      temperature: 0.1,
    });
    const message = response.choices[0].message;
    if (!message.tool_calls?.length) {
      return message.content;
    }
    messages.push(message);
    for (const toolCall of message.tool_calls) {
      if (toolCall.type !== "function") {
        continue;
      }
      const args = JSON.parse(toolCall.function.arguments);
      const results = await webSearch(args.objective, args.search_queries, sessionId);
      messages.push({
        role: "tool",
        tool_call_id: toolCall.id,
        content: JSON.stringify(results),
      });
    }
  }
  throw new Error("The model did not finish answering within maxSteps.");
}

answer("What is the latest stable release of Python, and what is new in it?").then(console.log);