Forem: Reka

Apps That See: Bringing Vision AI to Your Projects

Frank Boucher ☁ — Tue, 05 May 2026 20:12:58 +0000

I was wearing a t-shirt with a partial Reka logo at the edge of the frame. I never said the word "Reka" in that segment. The model caught the logo, connected it to the topic I was discussing, and mentioned it unprompted in the output it generated.

That is not a transcript trick. The model was watching.

At the AI Agents Conference 2026, I gave a talk called "Apps That See" — six live demos showing how to build applications that understand images and video. Every project is open source and ready to clone. This post walks through each one so you have enough context to pick it up, run it, and adapt it to something useful in your own work.

Vision AI Is Accessible Now

Not long ago, working with visual AI meant GPU clusters, specialized teams, and weeks of training. Today a compressed 4B model like Qwen or Gemini 3 runs on a regular laptop and handles image description well enough to prototype. Step up to a 7B model like Reka Edge and the quality improves meaningfully. It also runs locally: a gaming PC with a decent GPU is enough. No server required.

For tasks that need more power, cloud APIs give you faster results without local hardware requirements. The tradeoff is that your images and video go to a third-party provider. For corridor cameras or stock photos that is usually acceptable. For private or sensitive content, local is the better default.

The practical pattern: start local to build and test, then decide whether the task actually requires cloud.

What You Can Build With This

Accessibility: Describe a scene in real time for visually impaired users, or identify objects on demand.
Content creation: Extract structure from a video and turn it into a blog post, caption set, or highlight reel.
Productivity: Search through thousands of videos for a specific object or topic, even when the title gives no indication of the content.
Automation: Trigger actions only when specific visual conditions are met, such as an unrecognized person entering a room.
Fun: Most developers' first contact with AI is building something for themselves, and that is a perfectly valid starting point.

Demo 1: Caption This — Generate a Prompt from Any Image

Source: fboucher/caption-this

If you work with image generation models, you end up with a lot of images to test and compare. Writing the text prompt that would reproduce a specific image is tedious. This tool does it for you: give it an image, get back a prompt you can use to regenerate something similar.

The demo uses an HTTP client extension in VS Code to call the API directly, no SDK. Pass an image, ask for a plain-text prompt that would recreate it. One prompt detail that improved results noticeably: add no markdown to the instruction.

POST https://api.reka.ai/v1/chat
Content-Type: application/json

{
  "model": "reka-flash",
  "messages": [{
    "role": "user",
    "content": [
      { "type": "image_url", "image_url": { "url": "https://..." } },
      { "type": "text", "text": "Write a prompt in plain text, no markdown, that would generate the exact same image." }
    ]
  }]
}

One thing to know when testing this across different models: some accept an image URL directly, others require the image as a base64-encoded string. Same task, same prompt, different input contract. If you plan to swap models in your app, account for this difference from the start.

Demo 2: Media Library — Compare Vision Models Side by Side

Source: fboucher/media-library

This is a web app that connects to multiple vision backends and lets you switch between them at runtime. The motivation: benchmark Reka Edge running locally — via OpenRouter or directly through the Reka API — against other models on real tasks.

Object detection surfaces the biggest portability problem. Some models return bounding boxes in an HTML-style bracket format with pixel coordinates. Others use a 2D box structure with a different coordinate scheme. If you code against one format and then swap models, your rendering breaks. There is no standard here — handle the differences at the application layer, not the model layer.

The app uses the OpenAI API format as the common interface across all backends. Any model with a compatible endpoint can be swapped in with minimal changes. It does not eliminate the per-model quirks, but it reduces the friction of switching to a configuration change rather than a rewrite.

Video input is supported too, though far fewer models handle it than images. Of the models tested, Reka Edge is the standout for video — the others either reject it or behave inconsistently.

Demo 3: Video2Blog — Turn a Video into a Structured Post

Source: fboucher/video2blog

I built this for myself. I do a lot of tutorial videos and I wanted a tool that would turn a recording into a structured blog post without me having to write one from scratch.

The tool sends the video to a vision model with a detailed prompt: target structure, tone, format, and an instruction to flag moments where a screenshot would add value. The model returns timestamps — it cannot extract frames itself, but it tells you exactly where to look, and you pull them locally with ffmpeg.

That creates one architectural quirk worth knowing: the video lives in two places. ffmpeg needs it locally to extract frames. The hosted model needs it uploaded to analyze content. For a one-evening project it works well enough, and I use it often enough that it has paid for itself many times over.

After the first draft, you stay in a conversation loop: change the tone, translate to French, swap a timestamp, restructure a section. The model holds context and iterates with you until the result is what you want.

Demo 4: Video Analyzer — Search and Query Your Video Library

Source: reka-ai/api-examples-dotnet

Most video search runs on titles, descriptions, and transcribed audio. This demo searches by what is actually visible on screen.

The app pre-indexes a video library by sending each video through a vision model ahead of time. When a query arrives, the heavy work is already done. A search for "robot arm" returns the right video — a clip of a robotic arm animation. It also returns a false positive: fast-moving hands apparently looked close enough to fool the model. Useful, not perfect, and worth designing around in your UX.

The Q&A feature goes further. You pick a video and ask a specific question. "What database was used?" returned MySQL — and noted it was running in a Docker container. The model identified that from watching the screen, not from audio. No transcript needed.

From there, you can generate study materials from any recorded session. The demo produces a multiple-choice quiz with answer options, correct answers, and explanations. The model is doing comprehension, not transcription.

Demo 5: Roast My Life — What the Model Actually Sees

Source: reka-ai/api-examples-python

I never mentioned the pictures on my wall. The model did.

In a video about Python and AI, the model's generated blog post made a remark about the artwork hanging behind me. I had said nothing about it. The model noticed, mentioned it, and moved on as if it were obvious.

Then there was the t-shirt moment described at the top of this post. A partial logo, half out of frame, no mention of it anywhere in the audio — and the model connected it to the topic anyway.

This demo is named Roast My Life because the model ends up commenting on things you never intended to share. But the real point is what it reveals: a vision model is not a smarter transcript. It is watching. The larger models do this particularly well, and once you see it, it changes how you think about what these tools can do — and what they will pick up without you asking.

Demo 6: N8N Automation — No-Code Video Clipping Pipeline

Sources: reka-ai/clip-api-examples · reka-ai/n8n-nodes-reka · N8N Reka Vision integration

Vision AI does not always need custom code. This demo wires everything together in N8N, a visual workflow tool, with no programming required.

The trigger is a new video published to YouTube. The workflow finds an engaging clip, reformats it from horizontal to vertical, adds captions in a specific style (all lowercase, specific colors — chosen to be obviously distinct from any default), and sends an email with the finished clip attached. The whole thing runs automatically.

For developers, this pattern is worth knowing even if you code everything else. Many real business workflows have a vision AI step that fits cleanly into a larger automation, and a no-code tool is often the fastest way to ship it.

Watch the Full Talk

The demos above are the written version. The live version, with the actual code running, models responding in real time, and a few things going sideways in interesting ways, is on YouTube.

Watch "Apps That See" from the AI Agents Conference 2026

All the Code

The demos span Python, C#, raw HTTP, Go, and N8N. Vision AI is not tied to a specific stack — if your environment can make an HTTP request, it can call a vision model.

All projects:

Bringing Reka Edge to Your Workflow via OpenRouter

Frank Boucher ☁ — Tue, 14 Apr 2026 13:22:11 +0000

Reka Edge, Reka's latest multimodal model, is now available on OpenRouter. In a previous post we ran the model locally using vLLM. This time, we connect the same app to OpenRouter so we can switch between models by changing a connection string and a model ID.

More of a visual learner? Grab some popcorn and watch the video. Prefer to read? Skip right past it, the full walkthrough continues below.

The full source code is available at github.com/fboucher/media-library.

Why Use OpenRouter?

OpenRouter is the largest AI gateway for developers. It gives you a single, unified API to access all major models. The OpenAI SDK works out of the box, so there is nothing new to learn.

Beyond convenience, OpenRouter provides higher availability through distributed infrastructure with automatic fallback when a provider goes down. It runs at the edge for minimal latency, offers better prices with no subscriptions, and lets you set custom data policies so prompts only go to models and providers you trust.

Reka Edge and Reka Flash are both available on OpenRouter. Search for "Reka" or visit the Reka provider page to get started.

What You Need from OpenRouter

The Quick Start guide on OpenRouter provides examples for Python, TypeScript, and other SDKs. To connect any app, you need three things:

An API Key to authenticate your requests.
The endpoint URL: https://openrouter.ai/api/v1
The model ID for the model you want to use. In our case, rekaai/reka-edge.

Seeing It in Action

In the previous post, we used a media-library app to run Reka Edge locally with vLLM. Let's use the same app and add a new OpenRouter connection to it. All we need to do is pass the three pieces of information collected above: the URL, the API key, and the model ID.

Once saved, switch to the OpenRouter connection from the dropdown, upload an image, and click "Fill with AI." Reka Edge processes the image through OpenRouter and returns a detailed description. No changes to the application code were needed.

The beauty of OpenRouter is exactly this: you just change the connection string and the model. Both Reka Edge and Reka Flash are available, and you could have all your models centralized in one place.

How to Serve a Vision AI Model Locally with vLLM and Reka Edge

Frank Boucher ☁ — Wed, 08 Apr 2026 13:16:10 +0000

Running an AI model as a one-shot script is useful, but it forces you to restart the model every time you need a result. Setting it up as a service lets any application send requests to it continuously, without reloading the model. This guide shows how to serve Reka Edge using vLLM and an open-source plugin, then connect a web app to it for image description and object detection.

The vLLM plugin is available at github.com/reka-ai/vllm-reka. The demo Media Library app is at github.com/fboucher/media-library.

Prerequisites

You need a machine with a GPU and either Linux, macOS, or Windows (with WSL). I use UV, a fast Python package and project manager, or pip + venv if you prefer.

Clone the vLLM Reka Plugin

Reka models require a dedicated plugin to run under vLLM, not all models need this extra step, but Reka's architecture requires it. Clone the plugin repository and enter the directory:

git clone https://github.com/reka-ai/vllm-reka
cd vllm-reka

The repository contains the plugin code and a serve.sh script you will use to start the service.

Download the Reka Edge Model

Before starting the service, you need the model weights locally. Install the Hugging Face Hub CLI and use it to pull the reka-edge-2603 model into your project directory:

uv sync
uv pip install huggingface_hub
uvx hf download RekaAI/reka-edge-2603 --local-dir ./models/reka-edge-2603

This is a large model, so make sure you have enough disk space and a stable connection.

Start the Service

Once the model is downloaded, start the vLLM service using the serve.sh script included in the plugin:

uv run bash serve.sh ./models/reka-edge-2603

The script accepts environment variables to configure which model to load and how much GPU memory to allocate. If your GPU cannot fit the model at default settings, open serve.sh and adjust the variables at the top. The repository README lists the available options. The service takes a few seconds to load the model weights, then starts listening for HTTP requests.

As an example with an NVIDIA GeForce RTX 5070, here are the settings I used to run the model:

export GPU_MEM=0.80
export MAX_LEN=4096
export MAX_BATCH_TOKENS=4096
export MAX_IMAGES=2
export MAX_VIDEOS=1
export VIDEO_NUM_FRAMES=4
uv run bash serve.sh ./models/reka-edge-2603

Connect the Media Library App

With the backend running, time to start the Media Library app. Clone the repository, jump into the directory, and run it with Docker:

git clone https://github.com/fboucher/media-library
cd media-library
docker compose up --build -d

Open http://localhost:8080 in your browser, then add a new connection with these settings:

Name: local (or any label you want)
IP address: your machine's local network IP (e.g. 192.168.x.x)
API key: leave blank or enter anything — no key is required for a local connection
Model: reka-edge-2603

Click Test to confirm the connection, then save it.

Try It: Image Description and Object Detection

Select an image in the app and choose your local connection, then click Fill with AI. The app sends the image to your vLLM service, and the model returns a natural language description. You can watch the request hit your backend in the terminal where the service is running.

Reka Edge also supports object detection. Type a prompt asking the model to locate a specific feature (ex: "face") and the model returns bounding-box coordinates. The app renders these as red boxes overlaid on the image. This works for any region you can describe in a prompt.

Switch to the Reka Cloud API

If your local GPU is too slow for production use, you can point the app at the Reka APIs instead. Add a new connection in the app and set the base URL to the Reka API endpoint. Get your API key from platform.reka.ai. OpenRouter is another option if you prefer a unified API across providers.

The model name stays the same (reka-edge-2603), so switching between local and cloud is just a matter of selecting a different connection in the app. The cloud API is noticeably faster because Reka's servers are more powerful than a local GPU (at least mine :) ). During development, use the local service to avoid burning credits; switch to the API for speed when you need it.

What You Can Build

The service you just set up accepts any image, or video via HTTP — point a script at a folder and you have a batch pipeline for descriptions, tags, or bounding boxes. Swap the prompt and you change what it extracts. The workflow is the same whether you are running locally or through the API.

References

Reka Edge model: huggingface.co/RekaAI/reka-edge-2603
vLLM Reka plugin: github.com/reka-ai/vllm-reka
Media Library app: github.com/fboucher/media-library
Reka API platform: platform.reka.ai

Generating Short Clips from Long Videos with Python

Frank Boucher ☁ — Tue, 24 Mar 2026 20:15:17 +0000

This guide walks through clip_generator.py, a script in the clip-api-examples repo that uses the Clip API to extract short, captioned segments from a longer video. You provide a video source, either a YouTube URL or a local MP4 file, and the script handles the rest: downloading or uploading the video, analyzing it, and rendering a new clip based on your instructions. The example in this guide uses a YouTube URL to keep the setup simple.

The full source code is available at github.com/reka-ai/clip-api-examples.

Prerequisites

Clone the repository and install dependencies:

git clone https://github.com/reka-ai/clip-api-examples
cd clip-api-examples/python
pip install -r requirements.txt

Then export your API key:

export REKA_API_KEY=your_key_here

If you don't have a key yet, get one here. Free credits renew every month.

Running the Script

From the python/ folder, run:

python clip_generator.py

The script prompts you for a YouTube URL. Paste it in, and the job starts immediately.

The Job Lifecycle

Once submitted, the job moves through several statuses printed to your terminal: queued, processing, then completed. This works because the script uses stream=True in its HTTP request, which keeps the connection open and lets the script poll in a loop until the job finishes. If you prefer, you can remove stream=True and instead make one call to create the job, then a separate polling call to check its status.

Customizing the Payload

The heart of the script is the create_clip function, which builds a payload for the API:

payload = {
    "video_url": url,
    "prompt": "create an engaging video clip highlighting the best moments",
    "template": "moment",
    "num_generations": 1,
    "generation_config": {
        "aspect_ratio": "9:16",
        "subtitles": True,
        "min_duration_seconds": 10,
        "max_duration_seconds": 30
    }
}

Each field is customizable:

prompt: Plain-language instruction. Examples: "the funniest moments", "the part where I did the demo". Treat it like a brief to an editor.
template: Controls the overall clip style. "moment" is one option; the repo includes others.
num_generations: Request multiple clip variations in one job, useful for comparing different cuts.
min_duration_seconds / max_duration_seconds: Keep these short during development for faster turnaround.
subtitles: Set to True to burn captions into the video, False to skip them.
aspect_ratio: "9:16" for TikTok/Reels, "1:1" for square, or keep the original.

The Output

When the job completes, the API returns a generated title, a description of the clip, and suggested hashtags. The video itself is already trimmed and has captions burned in. The demo in the video processed an 18-minute horizontal talk (no captions) into a 25-second vertical clip with orange subtitles.

Clone the repo, adjust the payload to fit your content, and happy clipping.

Private Vision AI: Run Reka Edge Entirely on Your Machine

Frank Boucher ☁ — Thu, 19 Mar 2026 13:17:39 +0000

Reka just released Reka Edge, a compact but powerful vision-language model that runs entirely on your own machine. No API keys, no cloud, no data, leaving your computer. I work at Reka, and putting together this tutorial was genuinely fun; I hope you enjoy running it as much as I did.

In three steps, you'll go from zero to asking an AI what's in any image or video.

What You'll Need

A machine with enough RAM to run a 7B parameter model (~16 GB recommended)
Git
uv, a fast Python package manager. Install it with: curl -LsSf https://astral.sh/uv/install.sh | sh. This works on macOS, Linux, and Windows (WSL). If you're on Windows without WSL, grab the Windows installer instead.

Step 1: Get the Model and Inference Code

Clone the Reka Edge repository from Hugging Face. This includes both the model weights and the inference code:

git clone https://huggingface.co/RekaAI/reka-edge-2603
cd reka-edge-2603

Grab a coffee while it downloads, the model weights are several GB.

Step 2: Fetch the Large Files

Hugging Face stores large files (model weights and images) using Git LFS. After cloning, these files exist on disk but contain only small pointer files, not the actual content.

First, make sure Git LFS is installed. The command varies by platform:

# macOS
brew install git-lfs

# Linux / WSL (Ubuntu/Debian)
sudo apt install git-lfs

Then initialize it:

git lfs install

Then pull all large files, including model weights and media samples:

git lfs pull

Step 3: Ask the Model About an Image or Video

To analyze an image, use the sample included in the media/ folder:

uv run example.py \
  --image ./media/hamburger.jpg \
  --prompt "What is in this image?"

Or pass a video with --video:

uv run example.py \
  --video ./media/many_penguins.mp4 \
  --prompt "What is in this?"

The model will load, process your input, and print a description, all locally, all private.

Try different prompts to unlock more:

"Describe this scene in detail."
"What text is visible in this image?"
"Is there anything unusual or unexpected here?"

What's Actually Happening? (optional reading)

You don't need this to use the model, but if you're anything like me and can't help wondering what's going on under the hood, here's the magic behind example.py:

1. It picks the best hardware available.
The script checks whether your machine has a GPU (CUDA for Nvidia, Metal for Apple Silicon) and uses it automatically. If neither is available, it falls back to the CPU. This affects speed, not quality.

if torch.cuda.is_available():
    device = torch.device("cuda")
elif mps_ok:
    device = torch.device("mps")
else:
    device = torch.device("cpu")

2. It loads the model into memory.
The 7 billion parameter model is read from the folder you cloned. This is the "weights": billions of numbers that encode everything the model has learned. Loading takes ~30 seconds depending on your hardware.

processor = AutoProcessor.from_pretrained(args.model, trust_remote_code=True)
model = AutoModelForImageTextToText.from_pretrained(args.model, ...).eval()

3. It packages your input into a structured message.
Your image (or video) and your text prompt are wrapped together into a conversation-style format, the same way a chat message works, except one part is visual instead of text.

messages = [{
    "role": "user",
    "content": [
        {"type": "image", "image": args.image},
        {"type": "text", "text": args.prompt},
    ],
}]

4. It converts everything into numbers.
The processor translates your image into a grid of numerical patches and your prompt into tokens (small chunks of text, each mapped to a number). The model only understands numbers, so this step bridges the gap.

inputs = processor.apply_chat_template(
    messages, tokenize=True, return_tensors="pt", return_dict=True
)

5. The model generates a response, token by token.
Starting from your input, the model predicts the most likely next word, then the next, up to 256 tokens. It stops when it hits a natural end-of-response marker.

output_ids = model.generate(**inputs, max_new_tokens=256, do_sample=False)

6. It converts the numbers back into text and prints it.
The token IDs are decoded back into human-readable words and printed to your terminal. No internet involved at any point.

output_text = processor.tokenizer.decode(new_tokens, skip_special_tokens=True)
print(output_text)

Here the video

If you prefer watching and reading, here is the video version:

That's Pretty Cool, Right?

A single script. No API key. No cloud. You just ran a 7 billion parameter vision-language model entirely on your own machine, and it works whether you're on a Mac, Linux, or Windows with WSL, which is what I was using when I wrote this.

This works great as a one-off script: drop in a file, ask a question, get an answer. But what if you wanted to build something on top of it? A web app, a tool that watches a folder, or anything that needs to talk to the model repeatedly?

That's exactly what the next post is about. I'll show you how to wrap Edge as a local API, so instead of running a script, you have a service running on your machine that any app can plug into. Same model, same privacy, but now it's a proper building block.

Automatically Create AI Clips with This n8n Template

Frank Boucher ☁ — Thu, 29 Jan 2026 21:10:41 +0000

I'm excited to share that my new n8n template has been approved and is now available for everyone to use! This template automates the process of creating AI-generated video clips from YouTube videos and sending notifications directly to your inbox.

Try the template here: https://link.reka.ai/n8n-template-api

What Does This Template Do?

If you've ever wanted to automatically create short clips from long YouTube videos, this template is for you. It watches a YouTube channel of your choice, and whenever a new video is published, it uses AI to generate engaging short clips perfect for social media. You get notified by email when your clip is ready to download.

How It Works

The workflow is straightforward and runs completely on autopilot:

Monitor YouTube channels - The template watches the RSS feed of any YouTube channel you specify. When a new video appears, the automation kicks off.
Request AI clip generation - Using Reka's Vision API, the workflow sends the video for AI processing. You have full control over the output:
- Write a custom prompt to guide the AI on what kind of clip to create
- Choose whether to include captions
- Set minimum and maximum clip duration
Smart status checking - When the clips are ready, you receive a success email with your download link. As a safety feature, if the job takes too long, you'll get an error notification instead.

Getting Started is Easy

The best part? You can install this template with just one click from the n8n Templates page. No complex setup required!

After installation, you'll just need two quick things:

A free Reka AI API key (get yours from Reka)
A Gmail account (or use any email provider you like)

That's it! The template comes ready to use. Simply add your YouTube channel RSS feed, connect your API key, and you're ready to start generating clips automatically. The whole setup takes just a few minutes.

If you run into any questions or want to share what you've built, join the Reka Discord community. I'd love to hear how you're using this template!

Show Me

In this short video, I show you how to get that template into your n8n and how to configure it.

Happy clipping!

How to Leverage Reka Research to Build Smarter AI Apps

Frank Boucher ☁ — Tue, 16 Sep 2025 11:22:04 +0000

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 deep 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 set up

Prereqs: Node.js 18+ and npm.

Clone the repo and install deps

cd reka-restaurants
npm install

Get your Reka API Key

Visit the Reka Platform dashboard
Open “API keys” in the left nav
Create a new key (e.g., “reka-restaurants”) and copy it

Configure your environment

export REKA_API_KEY="<your_reka_api_key>"

Run the app

npm run build
npm start

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 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 deep 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.

Get an AI assistant to do your research

Frank Boucher ☁ — Thu, 07 Aug 2025 17:05:00 +0000

Introducing Reka Research: Your AI Research Assistant

Meet Reka Research a powerful AI agent that can search the web and analyze your files to answer complex questions in minutes. Whether you're staying up to date with AI news, screening resumes, or researching technical topics, Reka Research does the heavy lifting for you.

What Makes Reka Research Special?

Reka Research stands out in four key areas:

Top Performance : Best in class results on research benchmarks
Fast Results : Get thorough answers in 1-3 minutes
Full Transparency : See exactly how the AI reached its conclusions. All steps are visible.

Smart Web Search That Actually Works

Ever wished you could ask someone to research the latest AI developments while you focus on other work? That's exactly what Reka Research does.

Watch how it works:

In this demo, Jess and Sharath shows how Reka Research can automatically gather the most important AI news from the past week. The AI visits multiple websites, takes notes, and presents a clean summary with sources. You can even restrict searches to specific domains or set limits on how many sites to check.

File Search for Your Private Documents

Sometimes the information you need isn't on the web - it's in your company's documents, meeting notes, or file archives. Reka Research can search through thousands of private files to find exactly what you're looking for.

See it in action:

In this example, ess and Sharath shows how HR teams can use Reka Research to quickly screen resumes. Instead of manually reviewing hundreds of applications, the AI finds candidates who meet specific requirements (like having a computer science degree and 3+ years of backend experience) in seconds!

Writing Better Prompts Gets Better Results

Like any AI tool, Reka Research works best when you know how to ask the right questions. The key is being specific about what you want and providing context.

Learn the techniques:

Jess and Yi shares practical tips for getting the most out of Reka Research. Instead of asking "summarize meeting minutes," try "summarize April meeting minutes about public participation." The more specific you are, the better your results will be.

Ready to Try Reka Research?

Reka Research is currently available for everyone! Try it via the playground, or using directly the API. Whether you're researching competitors, analyzing documents, or staying current with industry trends, it can save you hours of work.

Want to learn more and connect with other users? Join our Discord community where you can:

Get tips from other Reka Research users
Share your use cases and success stories
Stay updated on new features and releases
Ask questions directly to our team

Join our Discord Community

Ready to transform how you research? Visit reka.ai to learn more about Reka Research and our other AI tools.

Forem: Reka

Apps That See: Bringing Vision AI to Your Projects

Vision AI Is Accessible Now

What You Can Build With This

Demo 1: Caption This — Generate a Prompt from Any Image

Demo 2: Media Library — Compare Vision Models Side by Side

Demo 3: Video2Blog — Turn a Video into a Structured Post

Demo 4: Video Analyzer — Search and Query Your Video Library

Demo 5: Roast My Life — What the Model Actually Sees

Demo 6: N8N Automation — No-Code Video Clipping Pipeline

Watch the Full Talk

All the Code

Bringing Reka Edge to Your Workflow via OpenRouter

Why Use OpenRouter?

What You Need from OpenRouter

Seeing It in Action

How to Serve a Vision AI Model Locally with vLLM and Reka Edge

Prerequisites

Clone the vLLM Reka Plugin

Download the Reka Edge Model

Start the Service

Connect the Media Library App

Try It: Image Description and Object Detection

Switch to the Reka Cloud API

What You Can Build

References

Generating Short Clips from Long Videos with Python

Prerequisites

Running the Script

The Job Lifecycle

Customizing the Payload

The Output

Private Vision AI: Run Reka Edge Entirely on Your Machine

What You'll Need

Step 1: Get the Model and Inference Code

Step 2: Fetch the Large Files

Step 3: Ask the Model About an Image or Video

What's Actually Happening? (optional reading)

Here the video

That's Pretty Cool, Right?

Automatically Create AI Clips with This n8n Template

What Does This Template Do?

How It Works

Getting Started is Easy

Show Me

How to Leverage Reka Research to Build Smarter AI Apps

Watch the video

Get the code and set up

The OpenAI‑compatible client

Structured outputs

Grounding results with the user’s location

Tuning breadth vs. latency with max_uses

Controlling sources with allowed_domains and blocked_domains

Transparent reasoning

Conclusion

Get an AI assistant to do your research

Introducing Reka Research: Your AI Research Assistant

What Makes Reka Research Special?

Smart Web Search That Actually Works

File Search for Your Private Documents

Writing Better Prompts Gets Better Results

Ready to Try Reka Research?

Tuning breadth vs. latency with `max_uses`

Controlling sources with `allowed_domains` and `blocked_domains`