Imagine having an assistant that could search across a curated list of sources, gather information, synthesize it, and present it in a structured format tailored to your needs. This is the power of Reka Research, an AI model designed to perform research by leveraging web searches and document analysis much faster than a human could. With tools like Reka Research integrated into your applications, you can create smarter, more reliable AI experiences. This post walks you through a demo app that showcases how to use Reka Research and fine-tune it by using advanced options and get better results, faster.

The following video show step‑by‑step how Reka Research powers a simple “Reka Restaurants” app that turns a craving (e.g., bagels”) into a short, structured list of nearby restaurants—plus a transparent reasoning trace. You can follow along and build it yourself! Clone the repo, and run the app locally.

Repo: the example lives in reka-restaurants inside: github.com/reka-ai/api-examples-typescript

Watch the video

Get the code and setup

Prerequisite: Node.js 18+ and npm.

1. Clone the repo and install dependancies
   
   

cd reka-restaurants
npm

2. Get your Reka API Key

In our recent End of Summer Updates, we announced that you can now sign-up for a 100% free API key! You can use this key to experiment with Reka Research and build your own applications. Get you free key by following these steps:

• Visit the Reka Platform dashboard

• Open “API keys” in the left nav

• Create a new key (e.g., “reka-restaurants”) and copy it

3. Configure your environment
   
   

export REKA_API_KEY="<your_reka_api_key>"

4. Run the app
   
   

npm run build
npm start

5. Try the app in your browser

• Open http://localhost:5173 and try a query like "sushi".

The OpenAI‑compatible client

In src/server.ts, the constant reka_research is the OpenAI‑compatible client for Reka:

const reka_research = new OpenAI(
  { apiKey: process.env.REKA_API_KEY, baseURL: 'https://api.reka.ai/v1' },
);

This makes it trivial to swap in Reka Research without changing your app stack. You only need to change the model to reka-flash-research and the baseURL.

Structured outputs

A great feature of Reka Research is the ability to specify the response format. This is extremely useful when you want to use the output directly in your application without additional parsing or processing. In our current example, by defining the expected answer to be a list of restaurants with the following information: name, cuisine type, address, price range, rating, url, why it was selected, that is exactly what we get back. This list can then be used directly by our application, saved to a database, or displayed to users, without any additional parsing or processing. Even better, specifying the schema helps guide the model to produce more accurate and relevant results.

The Reka Restaurant backend defines a response schema RestaurantItemSchema that the model must follow:

const RestaurantItemSchema = z.object({
  name: z.string(),
  cuisine: z.string(),
  address: z.string(),
  neighborhood: z.string().nullable(),
  approx_price: z.enum(["$", "$$", "$$$", "$$$$"]).nullable(),
  rating: z.number().nullable(),
  distance_km: z.number().nullable(),
  url: z.string().nullable(),
  why: z.string().nullable(),
});

When you submit a query, the agent performs web searches to gather relevant information. This may result in searching more websites to make sure all relevant information is found. The agent then opens and analyzes the content of these pages to extract the required details about each restaurant. Finally, it compiles this information into a structured list that adheres to the defined schema.

Grounding results with the user’s location

Instead of requiring users to type “near me” or specify a city, the app automatically uses the browser’s location to populate the API’s location parameter. This enables more accurate, relevant restaurant recommendations and a smoother user experience.

app.post('/api/recommendations', async (req: Request, res: Response) => {
  try {
    const user_query: string = (req.body?.query ?? '').toString();
    const loc: ApproxLocation = {
      country: req.body?.location?.country ?? null,
      city: req.body?.location?.city ?? null,
      region: req.body?.location?.region ?? null,
      timezone: req.body?.location?.timezone ?? null,
    };

Tuning breadth vs. latency with max_uses

Reka Research performs a series of steps (search, open, analyze). For simpler queries or when latency matters limit the number of web searches the agent performs:

Change the max_uses to the level of your choice. In this case, set it to 1 to allow only one web search before returning results. The agent may still open and analyze pages, but the trajectory is shorter and returns faster. This provides a good balance between depth and speed depending on the use case—sometimes you want a quick answer, other times you want more thorough research.

Try raising or lowering this value depending on how broad/deep you want the research to go.

research: {
web_search: {
    // Can be used to restrict the search to a specific domain(s). For example, to only search TripAdvisor.
    // A separate related field is "blocked_domains" to block specific domains.
    allowed_domains: ["tripadvisor.com"],
    // Limit the number of web searches Reka Research can do.
    max_uses: 1,
    // Can specify the user's location to ground the agent's search / response.
    user_location: {
    approximate: {
        country: loc?.country,
        city: loc?.city,
        region: loc?.region,
        timezone: loc?.timezone,
    },
    },
},
}

Controlling sources with allowed_domains and blocked_domains

When doing research, you may want to control which sources the agent can use. Online, not all sources are equally reliable or relevant for your use case. There are two parameters to help fine-tune the desired sources: allowed_domains and blocked_domains. In the code above, we set allowed_domains to only search "TripAdvisor". This limits the research to only that specific domain. This is useful when you want to ensure that the information comes from a curated list of sources. You can also use blocked_domains to exclude specific domains that you know are not reliable or relevant for your needs. These options give you a simple trust policy you can tune per use case.

Try adding or removing domains to Reka Restaurant demo in allowed_domains or experiment with blocked_domains to see how it impacts the results.

Transparent reasoning

The response includes a reasoning trace (the agent’s searches and analyses). This is very helpful to validate the information returned or understand why some results were or weren't selected in the final response. In this demo application, the frontend renders these steps so users can see which sources were queried and how results were formed.

Conclusion

Reka Research provides a practical foundation for building more powerful and intelligent applications. By adding the ability to actively search, analyze multiple sources, and return structured data, you can create apps that go beyond simple text generation. The transparency of the research process—showing which sources were used and how conclusions were reached—adds a layer of reliability that users can trust. It's this combination of enhanced capabilities and verifiable results that makes applications truly smarter.

What makes Reka Research particularly compelling is how effortlessly it integrates into existing workflows. If you're already using OpenAI's API, switching to Reka Research is literally a two-line change: update your baseURL to https://api.reka.ai/v1 and change the model to reka-flash-research. From there, you unlock powerful capabilities like location-grounded search, source control, and structured outputs that just work.

Whether you're building a restaurant finder, a research assistant, or any application that needs verified information, Reka Research gives you the tools to create smarter, more reliable AI experiences. Ready to try it yourself? Clone the restaurant finder repo and see the difference that Reka Research can make, or simply swap the URL in your existing OpenAI application and start experimenting today.

Have feedback or want to show what you built? Join our Discord community and check the docs at docs.reka.ai. We’d love to see what you create.