Forem: Kevin Wong

How to Build a Second Brain with OpenClaw: Text Anything to Remember, Search Everything Later

Kevin Wong — Wed, 08 Apr 2026 10:05:07 +0000

Start building your personal second brain today by integrating OpenClaw and WisGate API—capture anything you want to remember and find it instantly later. With this guide, you'll learn how to input text memories, store embeddings, and retrieve information efficiently through a custom-built interface.

Introduction to the Concept of a Second Brain Using OpenClaw
A "second brain" is a personal knowledge base that helps you store and search information effortlessly. Instead of relying solely on your memory, you create a system where you can text notes, ideas, or any data you want to remember. Later, you can search through all stored data to quickly find what you need.

OpenClaw is an open-source AI memory agent that enables this by converting your text inputs into embeddings — numerical representations that machines can store and analyze. It acts as the interface between you and your second brain, ingesting text and allowing fast semantic retrieval.

By combining OpenClaw with WisGate’s API, which provides access to advanced AI models like Claude Opus 4.6, you can create a scalable, cost-effective second brain. WisGate’s API supports large context windows and efficient token handling, ideal for building comprehensive memory storage and search applications.

Setting Up OpenClaw with WisGate API
To get your second brain running, you first need to configure OpenClaw to use WisGate as its AI provider. This involves editing the OpenClaw configuration file to add WisGate’s API base URL, your API key, and the model you want to use.

Editing the openclaw.json Configuration File
OpenClaw stores its settings in a JSON configuration file located at ~/.openclaw/openclaw.json. You’ll edit this file to define WisGate as a custom provider under the models section.

Open your terminal and run:

nano ~/.openclaw/openclaw.json
Then, add the following configuration snippet inside the models.providers block, defining a provider named "moonshot" that connects to WisGate’s API. Replace WISGATE-API-KEY with your actual WisGate API key.

"models": {
"mode": "merge",
"providers": {
"moonshot": {
"baseUrl": "https://api.wisgate.ai/v1",
"apiKey": "WISGATE-API-KEY",
"api": "openai-completions",
"models": [
{
"id": "claude-opus-4-6",
"name": "Claude Opus 4.6",
"reasoning": false,
"input": ["text"],
"cost": {
"input": 0,
"output": 0,
"cacheRead": 0,
"cacheWrite": 0
},
"contextWindow": 256000,
"maxTokens": 8192
}
]
}
}
}
This configuration tells OpenClaw to route its completion and memory synthesis calls through the WisGate API endpoint https://api.wisgate.ai/v1, using the Claude Opus 4.6 model customized for large context windows (256k tokens) and a maximum output of 8,192 tokens.

Restarting OpenClaw to Apply Changes
After saving your edits, you need to restart OpenClaw so the changes take effect. Use these terminal commands inside nano:

Press Ctrl + O to save the file.
Press Enter to confirm the filename.
Press Ctrl + X to exit nano.
Then, stop the currently running OpenClaw process if any by pressing:

Ctrl + C
Finally, start the OpenClaw text user interface again:

openclaw tui
Your OpenClaw installation is now set up to communicate with WisGate’s API for memory completion and retrieval.

Understanding the Core Components: Memory Ingestion, Embeddings, and Storage
At the heart of this second brain system are three core components: how text input is ingested, transformed into embeddings, and stored for future retrieval.

When you type or send any textual memory to OpenClaw, it ingests the text and sends it to the WisGate API’s Claude model to generate an embedding. An embedding is a high-dimensional vector that numerically encodes the semantic meaning of the text.

These embeddings are stored in a database or vector store within OpenClaw’s framework. This vectorized data allows OpenClaw to perform semantic search — you can query your memory with natural language and retrieve contextually relevant data rather than exact keyword matches.

This pattern follows retrieval-augmented generation (RAG), where external memory stores enhance language model responses. Your second brain effectively combines raw text memories, embedding vectors, and fast search interfaces to provide quick, relevant results.

Building a Semantic Search Interface with Next.js
Having your memories stored and embedded is just one part — you need an interface to search and view those memories efficiently. Next.js, a popular React framework, is a great choice for building a custom dashboard that queries your OpenClaw backend.

The Next.js app connects to your OpenClaw API and performs semantic search by sending natural language queries. It then displays ranked results based on similarity scores of the embedding vectors.

You can build UI components such as search bars, memory lists, and detailed views for each memory entry. This gives you a visual way to explore your second brain and instantly find any piece of information you previously stored.

By integrating API calls to the WisGate endpoint through OpenClaw, your Next.js dashboard supports live query completions and retrievals powered by the "claude-opus-4-6" model.

This approach turns your personal knowledge base into an interactive, user-friendly tool for memory management, leveraging advanced AI without building the models yourself.

Making WisGate API Calls for Memory Synthesis and Retrieval
Behind the scenes, OpenClaw makes HTTP requests to WisGate’s API at:

https://api.wisgate.ai/v1
It uses the Claude Opus 4.6 model, which supports a massive 256,000 token context window and returns up to 8,192 tokens in one completion. The model configuration specifies zero input or output costs within OpenClaw’s costing system, making resource usage transparent.

Example API payloads include your textual input converted into prompt data and requests for embedding vectors. WisGate handles the complex language modeling and returns text completions or vectors.

This combination allows OpenClaw to synthesize memories from raw text and retrieve relevant information efficiently, enabling your second brain workflow.

Pricing and Performance Considerations
When choosing an AI service for your second brain, cost and performance are key factors.

WisGate’s API offers image generation at approximately $0.058 per image, about 15% cheaper than the official rate of $0.068 per image. Even though this article focuses on textual memory synthesis, it highlights WisGate’s cost advantage.

Benchmarks show WisGate consistently delivers around 20-second response times for base64 output payloads ranging from 500 to 4,000 characters.

Using the "claude-opus-4-6" model on WisGate, you get a stable and large context window (256k tokens) with a max output of 8,192 tokens. This performance combined with lower cost makes WisGate a practical choice for memory augmentation setups.

For more on pricing and available models, visit WisGate’s homepage: https://wisgate.ai/models and explore creative assets with the AI Studio image tool: https://wisgate.ai/studio/image.

Conclusion and Next Steps
Building your own second brain using OpenClaw and WisGate API blends advanced AI memory management with affordable, scalable infrastructure. By following the step-by-step configuration and understanding the core concepts of ingestion, embedding, and semantic search, you can capture and recall anything important efficiently.

The custom Next.js dashboard adds a practical interface layer to interact with your memories when needed.

Get started now by signing up for WisGate at https://wisgate.ai/ and try out the "claude-opus-4-6" model for your next-generation personal memory system.

Explore the API documentation and create a second brain that grows and evolves with you.

How to Add AI Image Features to Your Website with Nano Banana 2 on WisGate AI

Kevin Wong — Tue, 31 Mar 2026 07:51:27 +0000

If you're using something like fal.ai, Replicate, or similar tools for image generation, you've probably hit at least one of these issues:

Models go offline without notice, and re-onboarding somewhere else takes days
Generation times swing wildly — 8 seconds one request, 40+ the next
Pricing is opaque until you're already scaling and the invoice surprises you

The switch to WisGate takes one config change. Nano Banana 2 is live, priced at $0.058/image (the official rate is $0.068), and generates consistently in 20 seconds whether you're at 0.5K or 4K. Below are two working tutorials — one for hair/beauty, one for interior design — so you can test it against your current provider in under 10 minutes.

Get your key at wisgate.ai/hall/tokens · Test prompts first at wisgate.ai/studio/image

Switching from Your Current Provider: One-Line Change

If you're on fal.ai or Replicate today, your integration probably looks like this:

# Your current call (fal.ai / Replicate / any competitor)
curl -X POST "https://api.yourprovider.com/v1/generate" \
  -H "Authorization: Bearer $THEIR_KEY" \
  -d '{"prompt": "...", "model": "their-model-id"}'

WisGate uses the Gemini-native endpoint format. Here's the full working call — this is what you replace your existing call with:

curl -s -X POST \
  "https://api.wisgate.ai/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "x-goog-api-key: $WISDOM_GATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "YOUR PROMPT HERE"}]}],
    "generationConfig": {
      "responseModalities": ["IMAGE"],
      "imageConfig": {
        "aspectRatio": "1:1",
        "imageSize": "1K"
      }
    }
  }' \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 --decode > output.png

Key differences from most providers:

Auth header is x-goog-api-key, not Authorization: Bearer
Response is inline Base64 — no cloud storage or URL expiry to manage
Set responseModalities: ["IMAGE"] for image-only output; use ["TEXT", "IMAGE"] if you also want a caption

Tutorial 1: Hair & Beauty — Virtual Color Try-On

Use case: a hair salon website where visitors can visualize a color change before booking.

curl -s -X POST \
  "https://api.wisgate.ai/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "x-goog-api-key: $WISDOM_GATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "Professional studio photo of a woman with a rich auburn balayage, natural lighting, clean white background, commercial hair photography style"}]}],
    "generationConfig": {
      "responseModalities": ["IMAGE"],
      "imageConfig": {
        "aspectRatio": "3:4",
        "imageSize": "2K"
      }
    }
  }' \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 --decode > hair_auburn_balayage.png

Prompt variables to swap per booking inquiry:

Color: "rich auburn balayage" → "platinum blonde highlights" / "deep burgundy ombre"
Style: "professional studio photo" → "editorial fashion shoot" / "natural outdoor light"
Aspect ratio: "3:4" works for portrait/mobile; switch to "1:1" for social media cards

At $0.058/image, generating 10 color previews per booking inquiry costs $0.58. At the same volume on a $0.068 provider, that's $0.68 — a small number per booking, but $1,000 different per 100,000 previews.

Tutorial 2: Interior Design — Room Visualization

Use case: a furniture or home decor website where shoppers can see how a style looks in a room before purchasing.

curl -s -X POST \
  "https://api.wisgate.ai/v1beta/models/gemini-3.1-flash-image-preview:generateContent" \
  -H "x-goog-api-key: $WISDOM_GATE_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"parts": [{"text": "Scandinavian minimalist living room, white oak flooring, linen sofa in warm ivory, large monstera plant in terracotta pot, afternoon natural light through floor-to-ceiling windows, architectural photography style"}]}],
    "generationConfig": {
      "responseModalities": ["IMAGE"],
      "imageConfig": {
        "aspectRatio": "16:9",
        "imageSize": "2K"
      }
    }
  }' \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 --decode > room_scandinavian.png

Style variants to build a full visualization set:

Style	Key prompt change
Scandinavian	`"white oak flooring, linen sofa, monstera plant"`
Industrial	`"exposed brick, black steel shelving, concrete floor"`
Japandi	`"low platform bed, washi paper lamp, bamboo accents"`
Maximalist	`"jewel tone walls, layered rugs, gallery wall art"`

Generate all four variants, display them as a style selector on the product page, and let shoppers click through before purchasing. Four images = $0.232 at WisGate rates.

Resolution Guide: Which `imageSize` for Which Use Case

Use case	`imageSize`	`aspectRatio`	Notes
Social media preview	`"1K"`	`"1:1"` or `"9:16"`	Fast, low cost for high volume
Website product image	`"2K"`	`"3:4"` or `"16:9"`	Standard for most web displays
Print or high-DPI screens	`"4K"`	Match your target format	Same 20-second generation time
Rapid prototyping	`"0.5K"`	Any	Useful during prompt development

All four sizes generate in the same consistent 20 seconds. Resize logic in your application can stay simple — same timeout threshold for every request.

The One-Line Switch

The full migration from any provider listed above — fal.ai, Replicate, Kie.ai, cometapi.com, piapi.ai, or zenmux.ai — is:

Base URL: https://api.wisgate.ai (replace generativelanguage.googleapis.com)
API Key: Replace $GEMINI_API_KEY with your $WISDOM_GATE_KEY

That's the entire migration. New models added to WisGate are available immediately without a separate onboarding process — same key, same endpoint format, just a different model ID.

Generate your key at wisgate.ai/hall/tokens and test your first prompt at wisgate.ai/studio/image before touching your production integration.