Forem: Reka

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

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`