DEV Community: Frank Boucher ☁

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!

Exposing Home Container with Traefik and Cloudflare Tunnel

Frank Boucher ☁ — Wed, 07 Jan 2026 12:48:00 +0000

I love the cloud, in fact most people probably know me because of my shared content related to that. But sometimes our apps don't need scaling, or redundancy. Sometimes we just want to host them somewhere.

French version available here

It was the holidays, and during my time off I worked on a few small personal projects. I packaged them in containers so it's easy to deploy anywhere. I deployed them on a mini-PC that I have at home and it is great... as long as I stay home. But what if I would like to access it from elsewhere (ex: my in-laws' house)?

I set up a nice Cloudflare tunnel to a Traefik container that proxies the traffic to the correct container based on the prefix or second-level domain. So dev.c5m.ca goes to container X and test.c5m.ca goes to container Y. In this post, I wanted to share how I did it (and also have it somewhere for me in case I need to do it again 😉). It's simple once you know all the pieces work together.

image generated by Microsoft designer

The Setup

The architecture is straightforward: Cloudflare Tunnel creates a secure connection from my home network to Cloudflare's edge, and Traefik acts as a reverse proxy that routes dynamically incoming requests to the appropriate container based on the subdomain. This way, I can access multi ple services through different subdomains without exposing my home network directly to the internet.

Step 1: Cloudflare Tunnel

First, assuming you already owne a domain name, you'll need to create a Cloudflare tunnel. You can do this through the Cloudflare dashboard under Zero Trust → Networks → Tunnels. Once created, you'll get a tunnel token that you'll use in the configuration.

Here's my cloudflare-docker-compose.yaml:

name: cloudflare-tunnel

services:
  cloudflared:
    image: cloudflare/cloudflared:latest
    container_name: cloudflared
    restart: unless-stopped
    env_file:
      - .env
    environment:
      - TUNNEL_TOKEN=${TUNNEL_TOKEN}
    command: ["tunnel", "--no-autoupdate", "run", "--token", "${TUNNEL_TOKEN}"]

The tunnel token is stored in a .env file for security. The --no-autoupdate flag prevents the container from trying to update itself automatically, which is useful in a controlled environment.

Step 2: DNS Configuration

In Cloudflare dashboard, create a CNAME Record with a wildcard. For example for my domain "c5m.ca" that record will look like this: *.c5m.ca.

Step 3: Traefik Configuration

Traefik is the reverse proxy that will route traffic to your containers. I have two configuration files: one for Traefik itself and one for the Docker Compose setup.

Here's my traefik.yaml:

global:
  checkNewVersion: false
  sendAnonymousUsage: false

api:
  dashboard: false #true
  insecure: true

entryPoints:
  web:
    address: :8082
  websecure:
    address: :8043

providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false

I've configured two entry points: web on port 8082 (HTTP) and websecure on port 8043 (HTTPS). I did it that way because the default 80 and 443 where already taken. The Docker provider watches for containers with Traefik labels and automatically configures routing. exposedByDefault: false means containers won't be exposed unless explicitly enabled with labels. You won't have to change Traefik config to add more containers, it's all dynamic.

And here's the traefik-docker-compose.yaml:

name: traefik

services:
  traefik:
    image: "traefik:v3.4"
    container_name: "traefik-app"
    restart: unless-stopped
    networks:
      - proxy

    ports:
      - "8888:8080" # Dashboard port
      - "8082:8082"
      - "8043:8043" # remap 443
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "./config/traefik.yaml:/etc/traefik/traefik.yaml:ro"

networks:
  proxy:
    name: proxy

The key points here:

Traefik is connected to a Docker network called proxy that will be shared with other containers. You can name it the way you like.
Port 8888 maps to Traefik's dashboard (currently disabled in the config)
Ports 8082 and 8043 are exposed for HTTP and HTTPS traffic
The Docker socket is mounted read-only so Traefik can discover containers
The configuration file is mounted from ./config/traefik.yaml

Step 4: Configuring Services

Now, any container you want to expose through Traefik needs to:

Be on the same proxy network
Have Traefik labels configured

Here's a simple example with an nginx container (nginx-docker-compose.yaml):

name: "test-tools"

services:
  nginx:
    image: "nginx:latest"
    container_name: "nginx-test"
    restart: unless-stopped
    networks:
      - proxy
    volumes:
      - "./html:/usr/share/nginx/html:ro"

    labels:
      - traefik.enable=true
      - traefik.http.routers.nginxtest.rule=Host(`test.c5m.ca`) 
      - traefik.http.routers.nginxtest.entrypoints=web

networks:
  proxy:
    external: true

The labels tell Traefik:

traefik.enable=true: This container should be exposed
nginxtest is the unique name for routing this container.
traefik.http.routers.nginxtest.rule=Host(...): Route requests for test.c5m.ca to this container
traefik.http.routers.nginxtest.entrypoints=web: Use the web entry point (port 8082)

Bonus: A More Complex Example

For a more realistic scenario, let's share how I could expose 2D6 Dungeon Apphere's a simplified version of my 2d6-docker-compose.yaml which includes a multi-container application:

name: 2d6-dungeon

services:
  database:
    container_name: 2d6_db
    ports:
      - "${MYSQL_PORT:-3306}:3306"
    networks:
      - proxy
    ...

  dab:
    container_name: 2d6_dab
    ...
    depends_on:
      database:
        condition: service_healthy
    ports:
      - "${DAB_PORT:-5000}:5000"
    networks:
      - proxy

  webapp:
    container_name: 2d6_app
    depends_on:
      - dab
    environment:
      ConnectionStrings__dab: http://dab:5000
      services __dab__ http__0: http://dab:5000

    labels:
      - traefik.enable=true
      - traefik.http.routers.twodsix.rule=Host(`2d6.c5m.ca`)
      - traefik.http.routers.twodsix.entrypoints=web,websecure
      - traefik.http.services.twodsix.loadbalancer.server.port=${WEBAPP_PORT:-8080}

    networks:
      - proxy

    ports:
      - "${WEBAPP_PORT:-8080}:${WEBAPP_PORT:-8080}"

networks:
  proxy:
    external: true

This example shows:

Multiple services working together (database, API, web app)
Only the webapp is exposed through Traefik (the database and API are internal)
The webapp uses both web and websecure entry points
Important note here is that container part of the same network can use their internal port (ex: 5000 for DAB, 3306 for MySQL)
The external network is the proxy created previously

Cloudflare Tunnel Configuration

In your Cloudflare dashboard, you'll need to configure the tunnel to route traffic to Traefik. Create a public hostname that points to http://<local-ip>:8082. Use the local IP of your server something like "192.168.1.123" You can use wildcards like *.c5m.ca to route all subdomains to Traefik, which will then handle the routing based on the hostname.

Wrapping Up

That's it! Once everything is set up:

The Cloudflare tunnel creates a secure connection from your home to Cloudflare
Traffic comes in through Cloudflare and gets routed to Traefik
Traefik reads the hostname and routes to the appropriate container
Each service can be accessed via its own subdomain
Only the containers with the Traefik labels are accessible from outside my network
It's dynamic! Any new container, with the labels, will be routed without changing the config in Traefik nor Cloudflare

It's a simple setup that works great for personal projects. The best part is that you don't need to expose any ports on your router or deal with dynamic DNS, Cloudflare handles all of that.

Next step will be to add some authentication and authorization (ex: using Keycloak), but that's for another post. For now, this gives me a way to access my home-hosted services from anywhere, and I thought it could be useful to share.

From Hours to Minutes: AI That Finds Tech Events for You

Frank Boucher ☁ — Mon, 05 Jan 2026 08:30:00 +0000

TL;DR

I built an AI research agent that actually browses the live web and finds tech events, no search loops, no retry logic, no hallucinations. Just ask a question and get structured JSON back with the reasoning steps included. The secret? An API that handles multi-step research automatically. Built with .NET/Blazor in a weekend. Watch me build it | Get the code | Free API key

Happy New Year! I wanted to share something I recently presented at the AI Agents Conference 2025: how to build intelligent research assistants that can search the live web and return structured, reliable results.

Coming back from the holidays, I'm reminded of a universal problem: information overload. Whether it's finding relevant tech conferences, catching up on industry news, or wading through piles of documentation that accumulated during time off, we all need tools that can quickly search and synthesize information for us. That's what Reka Research does it's an agentic AI that browses the web (or your private documents), answers complex questions, and turns hours of research into minutes. I built a practical demo to show this in action: an Event Finder that searches the live internet for upcoming tech conferences.

The full presentation is available on YouTube if you want to follow along: How to Build Agentic Web Research Assistants

The Problem: Finding Events Isn't Just a Simple Search

Let me paint a picture. You want to find upcoming tech conferences about AI in your area. You need specific information: the event name, start and end dates, location, and most importantly, the registration URL.

A simple web search or basic LLM query falls short because:

You might get outdated information
The first search result rarely contains all required details
You need to cross-reference multiple sources
Without structure, the data is hard to use in an application

This is where Reka's Research API shines. It doesn't just search it reasons through multiple steps, aggregates information, and returns structured, grounded results.

The Solution: Multi-Step Research That Actually Works

The core innovation here is multi-step grounding. Instead of making a single query and hoping for the best, the Research API acts like a diligent human researcher:

It makes an initial search based on your query
Checks what information is missing
Performs additional targeted searches
Aggregates and validates the data
Returns a complete, structured response

As a developer, you simply send your question, and the API handles the complex iteration. No need to build your own search loops or retry logic.

How It Works: The Developer Experience

Here's what surprised me most: the simplicity. You define your data structure, ask a question, and the API handles all the complex research orchestration. No retry logic, no search loop management.

The key is structured output. Instead of parsing messy text, you tell the API exactly what JSON schema you want:

public class TechEvent
{
    public string? Name { get; set; }
    public DateTime? StartDate { get; set; }
    public DateTime? EndDate { get; set; }
    public string? City { get; set; }
    public string? Country { get; set; }
    public string? Url { get; set; }
}

Then you send your query with the schema, and it returns perfectly structured data every time. The API uses OpenAI compatible format, so if you've worked with ChatGPT's API, this feels instantly familiar.

The real magic? You also get back the reasoning steps the actual web searches it performed and how it arrived at the answer. Perfect for debugging and understanding the agent's thought process.

I walk through the complete implementation, including domain filtering, location aware search, and handling the async research calls in the video. The full source code is on GitHub if you want to dive deeper.

Try It Yourself

The complete source code is on GitHub. Clone it, grab a free API key, and you'll have it running in under 5 minutes.

I'm curious what you'll build with this. Research agents that monitor news? Product comparison tools? Documentation synthesizers? The API works for any web research task. If you build something, tag me. I'd love to see it.

Happy New Year! 🎉

Ask AI from Anywhere: No GUI, No Heavy Clients, No Friction

Frank Boucher ☁ — Wed, 26 Nov 2025 16:33:00 +0000

Ever wished you could ask AI from anywhere without needing an interface? Imagine just typing ? and your question in any terminal the moment it pops into your head, and getting the answer right away! In this post, I explain how I wrote a tiny shell script that turns this idea into reality, transforming the terminal into a universal AI client. You can query Reka, OpenAI, or a local Ollama model from any editor, tab, or pipeline—no GUI, no heavy clients, no friction.

Small, lightweight, and surprisingly powerful: once you make it part of your workflow, it becomes indispensable.

💡 All the code scripts are available at: https://github.com/reka-ai/terminal-tools

The Core Idea

There is almost always a terminal within reach—embedded in your editor, sitting in a spare tab, or already where you live while building, debugging, and piping data around. So why break your flow to open a separate chat UI? I wanted to just type a single character (?) plus my question and get an answer right there. No window hopping. No heavy client.

How It Works

The trick is delightfully small: send a single JSON POST request to whichever AI provider you feel like (Reka, OpenAI, Ollama locally, etc.):

# Example: Reka
curl https://api.reka.ai/v1/chat
     -H "X-Api-Key: <API_KEY>" 
     -d {
          "messages": [
            {
              "role": "user",
              "content": "What is the origin of thanksgiving?"
            }
          ],
          "model": "reka-core",
          "stream": false
        }


# Example: Ollama local
curl http://127.0.0.1:11434/api/chat 
-d {  
      "model": "llama3",   
      "messages": [
        {
          "role": "user", 
          "content": "What is the origin of thanksgiving?"
        }], 
      "stream": false
    }

Once we get the response, we extract the answer field from it. A thin shell wrapper turns that into a universal “ask” verb for your terminal. Add a short alias (?) and you have the most minimalist AI client imaginable.

Let's go into the details

Let me walk you through the core script step-by-step using reka-chat.sh, so you can customize it the way you like. Maybe this is a good moment to mention that Reka has a free tier that's more than enough for this. Go grab your key—after all, it's free!

The script (reka-chat.sh) does four things:

Captures your question
Loads an API key from ~/.config/reka/api_key
Sends a JSON payload to the chat endpoint with curl.
Extracts the answer using jq for clean plain text.

1. Capture Your Question

This part of the script is a pure laziness hack. I wanted to save keystrokes by not requiring quotes when passing a question as an argument. So ? What is 32C in F works just as well as ? "What is 32C in F".

if [$# -eq 0]; then
    if [! -t 0]; then
        QUERY="$(cat)"
    else
        exit 1
    fi
else
    QUERY="$*"
fi

2. Load Your API Key

If you're running Ollama locally you don't need any key, but for all other AI providers you do. I store mine in a locked-down file at ~/.config/reka/api_key, then read and trim trailing whitespace like this:

API_KEY_FILE="$HOME/.config/reka/api_key"
API_KEY=$(cat "$API_KEY_FILE" | tr -d '[:space:]')

3. Send The JSON Payload

Building the JSON payload is the heart of the script, including the API_ENDPOINT, API_KEY, and obviously our QUERY. Here’s how I do it for Reka:

RESPONSE=$(curl -s -X POST "$API_ENDPOINT" \
     -H "X-Api-Key: $API_KEY" \
     -H "Content-Type: application/json" \
     -d "{
  \"messages\": [
    {
      \"role\": \"user\",
      \"content\": $(echo "$QUERY" | jq -R -s .)
    }
  ],
  \"model\": \"reka-core\",
  \"stream\": false
}")

4. Extract The Answer

Finally, we parse the JSON response with jq to pull out just the answer text. If jq isn't installed we display the raw response, but a formatted answer is much nicer. If you are customizing for another provider, you may need to adjust the JSON path here. You can add echo "$RESPONSE" >> data_sample.json to the script to log raw responses for tinkering.

With Reka, the response look like this:

{
    "id": "cb7c371b-3a7b-48d2-829d-70ffacf565c6",
    "model": "reka-core",
    "usage": {
        "input_tokens": 16,
        "output_tokens": 460,
        "reasoning_tokens": 0
    },
    "responses": [
        {
            "finish_reason": "stop",
            "message": {
                "role": "assistant",
                "content": " The origin of Thanksgiving ..."
            }
        }
    ]
}

The value we are looking for and want to display is the content field inside responses[0].message. Using jq, we do:

echo "$RESPONSE" | jq -r '.responses[0].message.content // .error // "Error: Unexpected response format"'

Putting It All Together

Now that we have the script, make it executable with chmod +x reka-chat.sh, and let's add an alias to your shell config to make it super easy to use. Add one line to your .zshrc or .bashrc that looks like this:

alias \\?=\"$REKA_CHAT_SCRIPT\"

Because ? is a special character in the shell, we escape it with a backslash. After adding this line, reload your shell configuration with source ~/.zshrc or source ~/.bashrc, and you are all set!

The Result

Now you can ask questions directly from your terminal. Wanna know what is origin of Thanksgiving, ask it like this:

? What is the origin of Thanksgiving

And if you want to keep the quotes, please you do you!

Extra: Web research

I couldn't stop there! Reka also supports web research , which means it can fetch and read web pages to provide more informed answers. Following the same pattern described previously, I wrote a similar script called reka-research.sh that sends a request to Reka's research endpoint. This obviously takes a bit more time to answer, as it's making different web queries and processing them, but the results are often worth the wait—and they are up to date! I used the alias ?? for this one.

On the GitHub repository, you can find both scripts (reka-chat.sh and reka-research.sh) along with a script to create the aliases automatically. Feel free to customize them to fit your workflow and preferred AI provider. Enjoy the newfound superpower of instant AI access right from your terminal!

What's Next?

With this setup, the possibilities are endless. Reka supports questions related to audio and video, which could be interesting to explore next. The project is open source, so feel free to contribute or suggest improvements. You can also join the Reka community on Discord to share your experiences and learn from others.

Resources

Check-In Doc MCP Server: A Handy Way to Search Only the Docs You Trust

Frank Boucher ☁ — Tue, 18 Nov 2025 10:30:00 +0000

Ever wished you could ask a question and have the answer come only from a handful of trusted documentation sites—no random blogs, no stale forum posts? That’s exactly what the Check-In Doc MCP Server does. It’s a lightweight Model Context Protocol (MCP) server you can run locally (or host) to funnel questions to selected documentation domains and get a clean AI-generated answer back.

What It Is

The project (GitHub: https://github.com/fboucher/check-in-doc-mcp) is a Dockerized MCP server that:

Accepts a user question.

Calls the Reka AI Research API with constraints (only allowed domains).

Returns a synthesized answer based on live documentation retrieval.

You control which sites are searchable by passing a comma‑separated list of domains (e.g. docs.reka.ai,docs.github.com). That keeps > results focused, reliable, and relevant.

What Is the Reka AI Research API?

Reka AI’s Research API lets you blend language model reasoning with targeted, on‑the‑fly web/document retrieval. Instead of a model hallucinating an answer from static training data, it can:

Perform limited domain‑scoped web searches.
Pull fresh snippets.
Integrate them into a structured response.

In this project, we use the research feature with a web_search block specifying:

allowed_domains: Only the documentation sites you trust.
max_uses: Caps how many retrieval calls it makes per query (controls cost & latency).

Details used here:

Model: reka-flash-research
Endpoint: http://api.reka.ai/v1/chat/completions
Auth: Bearer API key (generated from the Reka dashboard: https://link.reka.ai/free)

How It Works Internally

The core logic lives in ResearchService (src/Domain/ResearchService.cs). Simplified flow:

Initialization

Stores the API key + array of allowed domains, sets model & endpoint, logs a safe startup message.
Build Request Payload

The CheckInDoc(string question) method creates a JSON payload:
Send Request

Creates a HttpRequestMessage (POST), adds Authorization: Bearer <APIKEY>, sends JSON to Reka.
Parse Response

Deserializes into a RekaResponse domain object, returns the first answer string.

Adding It to VS Code (MCP Extension)

You can run it as a Docker-based MCP server. Two simple approaches:

Option 1: Via “Add MCP Server” UI

In VS Code (with MCP extension), click Add MCP Server.
Choose type: Docker image.
Image name: fboucher/check-in-doc-mcp.
Enter allowed domains and your Reka API key when prompted.

Option 2: Via `mcp.json` (Recommended)

Alternatively, you can manually configure it in your mcp.json file. This will make sure your API key isn't displayed in plain text. Add or merge this configuration:

{
  "servers": {
    "check-in-docs": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "ALLOWED_DOMAINS=${input:allowed_domains}
        ",
        "-e",
        "APIKEY=${input:apikey}",
        "fboucher/check-in-doc-mcp"
      ]
    }
  },
  "inputs": [
    {
      "id": "allowed_domains",
      "type": "promptString",
      "description": "Enter the comma-separated list of documentation domains to allow (e.g. docs.reka.ai,docs.github.com):"
    },
    {
      "id": "apikey",
      "type": "promptString",
      "password": true,
      "description": "Enter your Reka Platform API key:"
    }
  ]
}

How to Use It

To use it ask to Check In Doc something or You can now use the SearchInDoc tool in your MCP-enabled environment. Just ask a question, and it will search only the specified documentation domains.

Final Thoughts

It’s intentionally simple—no giant orchestration layer. Just a clean bridge between a question, curated domains, and a research-enabled model. Sometimes that’s all you need to get focused, trustworthy answers.

If this sparks an idea, clone it and adapt away. If you improve it (citations, richer error handling, multi-turn context)—send a PR!

Watch a quick demo

Links & References

AI Vision: Turning Your Videos into Comedy Gold (or Cringe)

Frank Boucher ☁ — Wed, 12 Nov 2025 19:40:00 +0000

I've spent most of my career building software in C# and .NET, and only used Python in IoT projects. When I wanted to build a fun project—an app that uses AI to roast videos, I knew it was the perfect opportunity to finally dig into Python web development.

The question was: where do I start? I hopped into a brainstorming session with Reka's AI chat and asked about options for building web apps in Python. It mentioned Flask, and I remembered friends talking about it being lightweight and perfect for getting started. That sounded right.

In this post, I share how I built "Roast My Life," a Flask app using the Reka Vision API.

The Vision (Pun Intended)

The app needed three core things:

List videos : Show me what videos are in my collection
Upload videos : Let me add new ones via URL
Roast a video : Send a selected video to an AI and get back some hilarious commentary

See it in action

Part 1: Getting Started Environment Setup

The first hurdle was always going to be environment setup. I'm serious about keeping my Python projects isolated, so I did the standard dance:

Before even touching dependencies, I scaffolded a super bare-bones Flask app. Then one thing I enjoy from C# is that all dependencies are brought in one shot, so I like doing the same with my python projects using requirements.txt instead of installing things ad‑hoc (pip install flask then later freezing).

Dropping that file in first means the setup snippet below is deterministic. When you run pip install -r requirements.txt, Flask spins up using the exact versions I tested with, and you won't accidentally grab a breaking major update.

Here's the shell dance that activates the virtual environment and installs everything:

cd roast_my_life/workshop
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Then came the configuration. We will need an API key and I don't want to have it hardoced so I created a .env file to store my API credentials:

API_KEY=YOUR_REKA_API_KEY
BASE_URL=https://vision-agent.api.reka.ai

To get that API key, I visited the Reka Platform and grabbed a free one. Seriously, a free key for playing with AI vision APIs? I was in.

With python app.py, I fired up the Flask development server and opened http://127.0.0.1:5000 in my browser. The UI was there, but... it was dead. Nothing worked.

Perfect. Time to build.

The Backend: Flask Routing and API Integration

Coming from ASP.NET Core's controller-based routing and Blazor, Flask's decorator-based approach felt just like home. All the code code goes in the app.py file, and each route is defined with a simple decorator. But first things first: loading configuration from the .env file using python-dotenv:

from flask import Flask, request, jsonify
import requests
import os
from dotenv import load_dotenv

app = Flask( __name__ )

# Load environment variables (like appsettings.json)
load_dotenv()
api_key = os.environ.get('API_KEY')
base_url = os.environ.get('BASE_URL')

All the imports packages are the same ones that needs to be in the requirements.txt. And we retreive the API key and base URL from environment variables, just like in .NET Core.

Now, to be able to get roasted we need first to upload a video to the Reka Vision API. Here's the code—I'll go over some details after.


@app.route('/api/upload_video', methods=['POST'])
def upload_video():
    """Upload a video to Reka Vision API"""
    data = request.get_json() or {}
    video_name = data.get('video_name', '').strip()
    video_url = data.get('video_url', '').strip()

    if not video_name or not video_url:
        return jsonify({"error": "Both video_name and video_url are required"}), 400

    if not api_key:
        return jsonify({"error": "API key not configured"}), 500

    try:
        response = requests.post(
            f"{base_url.rstrip('/')}/videos/upload",
            headers={"X-Api-Key": api_key},
            data={
                'video_name': video_name,
                'index': 'true', # Required: tells Reka to process the video
                'video_url': video_url
            },
            timeout=30
        )

        response_data = response.json() if response.ok else {}

        if response.ok:
            video_id = response_data.get('video_id', 'unknown')
            return jsonify({
                "success": True,
                "video_id": video_id,
                "message": "Video uploaded successfully"
            })
        else:
            error_msg = response_data.get('error', f"HTTP {response.status_code}")
            return jsonify({"success": False, "error": error_msg}), response.status_code

    except requests.Timeout:
        return jsonify({"success": False, "error": "Request timed out"}), 504
    except Exception as e:
        return jsonify({"success": False, "error": f"Upload failed: {str(e)}"}), 500

Once the information from the frontend is validated we make a POST request to the Reka Vision API's /videos/upload endpoint. The parameters are sent as form data, and we include the API key in the headers for authentication. Here I was using URLs to upload videos, but you can also upload local files by adjusting the request accordingly. As you can see, it's pretty straightforward, and the documentation from Reka made it easy to understand what was needed.

The Magic: Sending Roast Requests to Reka Vision API

Here's where things get interesting. Once a video is uploaded, we can ask the AI to analyze it and generate content. The Reka Vision API supports conversational queries about video content:

def call_reka_vision_qa(video_id: str) -> Dict[str, Any]:
    """Call the Reka Video QA API to generate a roast"""

    headers = {'X-Api-Key': api_key} if api_key else {}

    payload = {
        "video_id": video_id,
        "messages": [
            {
                "role": "user",
                "content": "Write a funny and gentle roast about the person, or the voice in this video. Reply in markdown format."
            }
        ]
    }

    try:
        resp = requests.post(
            f"{base_url}/qa/chat",
            headers=headers,
            json=payload,
            timeout=30
        )

        data = resp.json() if resp.ok else {"error": f"HTTP {resp.status_code}"}

        if not resp.ok and 'error' not in data:
            data['error'] = f"HTTP {resp.status_code} calling chat endpoint"

        return data

    except requests.Timeout:
        return {"error": "Request to chat API timed out"}
    except Exception as e:
        return {"error": f"Chat API call failed: {e}"}

Here we pass the video ID and a prompt asking for a "funny and gentle roast." The API responds with AI-generated content, which we can then send back to the frontend for display. I try to give more "freedom" to the AI by asking it to reply in markdown format, which makes the output more engaging.

Try It Yourself!

The complete project is available on GitHub: reka-ai/api-examples-python

What Makes Reka Vision API So nice to use

What really stood out to me was how approachable the Reka Vision API is. You don't need any special SDK—just the requests library making standard HTTP calls. And honestly, it doesn't matter what language you're used to; an HTTP call is pretty much always simple to do. Whether you're coming from .NET, Python, JavaScript, or anything else, you're just sending JSON and getting JSON back.

Authentication is refreshingly straightforward: just pop your API key in the header and you're good to go. No complex SDKs, no multi-step authentication flows, no wrestling with binary data streams. The conversational interface lets you ask questions in natural language, and you get back structured JSON responses with clear fields.

One thing worth noting: in this example, the videos are pre-uploaded and indexed, which means the responses come back fast. But here's the impressive part—the AI actually looks at the video content. It's not just reading a transcript or metadata; it's genuinely analyzing the visual elements. That's what makes the roasts so spot-on and contextual.

Final Thoughts

The Reka Vision API itself deserves credit for making video AI accessible. No complicated SDKs, no multi-GB model downloads, no GPU requirements. Just simple HTTP requests and powerful AI capabilities. I'm not saying I'm switching to Python full-time, but expect to see me sharing more Python projects in the future!

References and Resources

GitHub Repository : reka-ai/api-examples-python
Join Reka community and share what you build! You can find me there as fboucheros.

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.

Using AI with .NET 10 Scripts: What Worked, What Didn’t, and Lessons Learned

Frank Boucher ☁ — Thu, 04 Sep 2025 14:57:00 +0000

I wanted to kick the tires on the upcoming .NET 10 C# script experience and see how far I could get calling Reka’s Research LLM from a single file, no project scaffolding, no .csproj. This isn’t a benchmark; it’s a practical tour to compare ergonomics, setup, and the little gotchas you hit along the way. I’ll share what worked, what didn’t, and a few notes you might find useful if you try the same.

All the sample code (and a bit more) is here: reka-ai/api-examples-dotnet · csharp10-script. The scripts run a small “top 3 restaurants” prompt so you can validate everything quickly.

We’ll make the same request in three ways:

OpenAI SDK
Microsoft.Extensions.AI for OpenAI
Raw HttpClient

What you need

The C# "script" feature used below ships with the upcoming .NET 10 and is currently available in preview. If you prefer not to install a preview SDK, you can run everything inside the provided Dev Container or on GitHub Codespaces. I include a .devcontainer folder with everything set up in the repo.

Set up your API key

We are talking about APIs here so of course, you need an API key. Good news is that it's free to sign up with Reka and get one! It's a two-click process; more details are in the repository. The API key is then stored in a .env file, and each script loads environment variables using DotNetEnv.Env.Load(), so your key is picked up automatically. I went this way instead of using dotnet user-secrets because I thought it would be the way it would be done in a CI/CD pipeline or a quick script.

Run the demos

From the csharp10-script folder, run any of these scripts. Each line is an alternative.

dotnet run 1-try-reka-openai.cs
dotnet run 2-try-reka-ms-ext.cs
dotnet run 3-try-reka-http.cs

You should see a short list of restaurant suggestions.

OpenAI SDK with a custom endpoint

Reka's APIs are using the OpenAI format; therefore, I thought of using the NuGet package OpenAI. To reference a package in a script, you use the #:package [package name]@[package version] directive at the top of the file. Here is an example:

#:package OpenAI@2.3.0

// ...

var baseUrl = "http://api.reka.ai/v1";

var openAiClient = new OpenAIClient(new ApiKeyCredential(REKA_API_KEY), new OpenAIClientOptions
{
    Endpoint = new Uri(baseUrl)
});

var client = openAiClient.GetChatClient("reka-flash-research");

string prompt = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in Montreal";

var completion = await client.CompleteChatAsync(
    new List<ChatMessage>
    {
        new UserChatMessage(prompt)
    }
);

var generatedText = completion.Value.Content[0].Text;

Console.WriteLine($" Result: \n{generatedText}");

The rest of the code is more straightforward, you create a chat client, specify the Reka API URL, select the model, and then you send a prompt. And it works just as expected. However, not everything was perfect, but before I share more about that part, let's talk about Microsoft.Extensions.AI.

Microsoft Extensions AI for OpenAI

Another common way to use LLM in .NET is to use one ot the Microsoft.Extensions.AI NuGet packages. In our case Microsoft.Extensions.AI.OpenAI was used.

#:package Microsoft.Extensions.AI.OpenAI@9.8.0-preview.1.25412.6

// ....

var baseUrl = "http://api.reka.ai/v1";

IChatClient client = new ChatClient("reka-flash-research", new ApiKeyCredential(REKA_API_KEY), new OpenAIClientOptions
{
    Endpoint = new Uri(baseUrl)
}).AsIChatClient();

string prompt = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in Montreal";

Console.WriteLine(await client.GetResponseAsync(prompt));

As you can see, the code is very similar. Create a chat client, set the URL, the model, and add your prompt, and it works just as well.

That's two ways to use Reka API with different SDKs, but maybe you would prefer to go "SDKless", let's see how to do that.

Raw HttpClient calling the REST API

Without any SDK to help, there is a bit more line of code to write, but it's still pretty straightforward. Let's see the code:

using var httpClient = new HttpClient();

var baseUrl = "http://api.reka.ai/v1/chat/completions";

var requestPayload = new
{
    model = "reka-flash-research",
    messages = new[]
            {
                new
                {
                    role = "user",
                    content = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in New York city"
                }
            }
};

using var request = new HttpRequestMessage(HttpMethod.Post, baseUrl);
request.Headers.Add("Authorization", $"Bearer {REKA_API_KEY}");
request.Content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

var response = await httpClient.SendAsync(request);

var responseContent = await response.Content.ReadAsStringAsync();

var jsonDocument = JsonDocument.Parse(responseContent);

var contentString = jsonDocument.RootElement
    .GetProperty("choices")[0]
    .GetProperty("message")
    .GetProperty("content")
    .GetString();

Console.WriteLine(contentString);

So you create an HttpClient, prepare a request with the right headers and payload, send it, get the response, and parse the JSON to extract the text. In this case, you have to know the JSON structure of the response, but it follows the OpenAI format.

What did I learn from this experiment?

I used VS Code while trying the script functionality. One thing that surprised me was that I didn't get any IntelliSense or autocompletion. I tried to disable the DevKit extension and change the setting for OmniSharp but no luck. My guess is that because it's in preview, and it will works just fine in November 2025 when .NET 10 will be released.

In this light environment, I encountered some issues where, for some reason, I couldn't use a https endpoint, I had to use http. In the raw httpClient script, I had some errors with the Reflection that wasn't available. It could be related to the preview or something else, I didn't investigate further.

For the most part, everything worked as expected. You can use C# code to quickly execute some tasks without any project scaffolding. It's a great way to try out the Reka API and see how it works.

What's Next?

While writing those scripts, I encountered multiple issues that aren't related to .NET but more about the SDKs when trying to do more advanced functionalities like optimization of the query and formatting the response output. Since it goes beyond the scope of this post, I will share my findings in a follow-up post. Stay tuned!

Video version

Here is a video version of this post

Learn more

Reka docs: docs.reka.ai
Join the community on Discord: discord invite
Github: API Example for .NET

DEV Community: Frank Boucher ☁

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

Exposing Home Container with Traefik and Cloudflare Tunnel

The Setup

Step 1: Cloudflare Tunnel

Step 2: DNS Configuration

Step 3: Traefik Configuration

Step 4: Configuring Services

Bonus: A More Complex Example

Cloudflare Tunnel Configuration

Wrapping Up

From Hours to Minutes: AI That Finds Tech Events for You

TL;DR

The Problem: Finding Events Isn't Just a Simple Search

The Solution: Multi-Step Research That Actually Works

How It Works: The Developer Experience

Try It Yourself

Ask AI from Anywhere: No GUI, No Heavy Clients, No Friction

The Core Idea

How It Works

Let's go into the details

1. Capture Your Question

2. Load Your API Key

3. Send The JSON Payload

4. Extract The Answer

Putting It All Together

The Result

Extra: Web research

What's Next?

Resources

Check-In Doc MCP Server: A Handy Way to Search Only the Docs You Trust

What It Is

What Is the Reka AI Research API?

How It Works Internally

Adding It to VS Code (MCP Extension)

Option 1: Via “Add MCP Server” UI

Option 2: Via mcp.json (Recommended)

How to Use It

Final Thoughts

Watch a quick demo

Links & References

AI Vision: Turning Your Videos into Comedy Gold (or Cringe)

The Vision (Pun Intended)

See it in action

Part 1: Getting Started Environment Setup

The Backend: Flask Routing and API Integration

The Magic: Sending Roast Requests to Reka Vision API

Try It Yourself!

Option 2: Via `mcp.json` (Recommended)

Tuning breadth vs. latency with `max_uses`

Controlling sources with `allowed_domains` and `blocked_domains`