.gif)
We build custom applications 5x faster and cheaper 🚀
Book a Free Consultation
Stuck on an error? Book a 30-minute call with an engineer and get a direct fix + next steps. No pressure, no commitment.
Direct answer: To integrate Tavily AI Search with OpenClaw, treat Tavily as an external REST API: create an OpenClaw skill (installed/configured via ClawHub) that holds no long-lived secret state, store Tavily credentials (API key or OAuth client) in ClawHub-managed secrets, have the skill call Tavily’s HTTP endpoints to run queries and indexing operations (or accept webhooks from Tavily and validate their signatures), and push any stateful or long-running work (large document ingestion, retries, scheduling) to external infrastructure (worker queues, object storage, databases). Authenticate and authorize explicitly (API keys or OAuth tokens with correct scopes), log and surface API errors, and test with direct cURL/HTTP calls before wiring the skill into agents.
.png)
.png)
TAVILY_BASE and path with Tavily’s real URLs and use the secret stored in ClawHub as TAVILY_API\_KEY.const fetch = require('node-fetch');
async function runTavilySearch(query, apiKey) {
const url = 'https://api.tavily.example/v1/search'; // <b>//</b> replace with Tavily's real search endpoint
const body = { query }; // <b>//</b> payload shape depends on Tavily's API
const res = await fetch(url, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiKey}`,
},
body: JSON.stringify(body),
// <b>//</b> choose an appropriate timeout mechanism in real code
});
if (!res.ok) {
const text = await res.text();
throw new Error(`Tavily API error: ${res.status} ${text}`);
}
const json = await res.json();
return json;
}
// <b>//</b> Example usage inside a skill runtime where process.env.TAVILY_API_KEY is set by ClawHub
// (Wrap in your skill handler code)
curl -X POST 'https://api.tavily.example/v1/search' \
-H "Authorization: Bearer TAVILY_API_KEY_GOES_HERE" \
-H "Content-Type: application/json" \
-d '{"query":"find the invoice for order 12345"}'
Speak one‑on‑one with a senior engineer about your no‑code app, migration goals, and budget. In just half an hour you’ll leave with clear, actionable next steps—no strings attached.
1
ClawConnector returns 401 Unauthorized because the Tavily API key in ClawAuthToken is not being presented exactly as Tavily expects (wrong header/prefix, extra whitespace, expired/invalid key) or the OpenClaw runtime isn't loading the env var/token. Verify header name/format, token validity, and that the connector sends the value to the correct base URL and environment.
x-api-key vs Authorization: Bearer.# // test the key and header format
curl -i -H "x-api-key: $ClawAuthToken" https://api.tavily.example/health
// // Node fetch example
fetch('https://api.tavily.example/endpoint',{headers:{'x-api-key':process.env.ClawAuthToken}})
2
Direct answer: Ensure the vector size stored in ClawIndex matches the Tavily embedding dimension (1536). Either recreate/configure the index with dimension=1536, or transform each embedding to 1536 floats (truncate, pad with zeros, or re-embed). Verify the Tavily response, your env vars, and reindex after fixing.
Practical checks and actions:
# verify and fix embedding length
def fix_embedding(vec, target=1536):
// truncate or pad with zeros
if len(vec) > target:
return vec[:target]
if len(vec) < target:
return vec + [0.0] * (target - len(vec))
return vec
# usage before storing
emb = get_tavily_embedding(text) // returns list[float]
emb = fix_embedding(emb, 1536)
store_vector(id, emb)
3
The metadata is being lost because the ClawPipeline ingest step is transforming or replacing the Tavily document payload without copying the payload's title, url, and tags into the pipeline's output schema. In practice this happens when field names are nested/renamed, omitted by a mapping/transform, or overwritten by a later processing stage.
Example payload pattern to preserve:
{
// content for ingestion
"content":"...",
// preserve metadata explicitly
"metadata": { "title":"My Title", "url":"https://...", "tags":["a","b"] }
}
4
Direct answer: Make the ClawWebhook-to-ClawSyncJob flow idempotent and verifiable — validate the Tavily signature, extract a stable event_id/version, persist an enqueue record (or lock) in an external store, immediately ack the webhook, and have ClawSyncJob check that store (or use an upsert with version checks and a unique constraint) before applying updates. Use short distributed locks to prevent concurrent processing and compare versions/timestamps to avoid out-of-order misses.
Practical steps:
// express webhook handler
app.post('/claw/webhook', async (req,res)=>{
// validate signature
const evt = req.body;
const id = evt.id;
// dedupe: Redis SETNX
const ok = await redis.set(id,'1','NX','EX',60);
if(!ok) return res.status(200).send('duplicate');
await queue.add({id,evt});
res.status(200).send('ok');
});
// worker
queue.process(async job=>{
const {id,evt}=job.data;
// upsert with version check (Postgres)
await db.query(
`INSERT INTO events(id,version,status) VALUES($1,$2,'processed')
ON CONFLICT (id) DO UPDATE SET version=EXCLUDED.version,status='processed'
WHERE events.version < EXCLUDED.version`, [id, evt.version]
);
});
This prompt helps an AI assistant understand your setup and guide you through the fix step by step, without assuming technical knowledge.
From startups to enterprises and everything in between, see for yourself our incredible impact.
They do complex work on extremely fast timelines and effectively manage the testing and pre-launch process to deliver the best possible product. I'm extremely impressed with their execution ability.
