Tavily

Tavily AI

Tavily AI

Tavily AI

Tavily AI

Tavily AI

Tavily AI

Tavily AI

Tavily AI

Tavily AI

Tavily AI

My pre-coding routine with Claude Code, 5 MCP servers before I write a single line

Been running this routine for months now. Started because I was losing too much time to Claude just guessing. Halluzinated class names, outdated SDK methods, advice that didn't match the codebase I was actually in. So I built a routine I run before I let it write anything. Takes maybe 60-90 seconds. Saved me hundreds of hours by now. Start the session and load memory. A memory MCP carries context across sessions. Last sprint, open decisions, recent learnings, why we picked X over Y three months ago. Without this, every session starts cold and Claude rebuilds my reasoning from scratch, usually wrong. Index the codebase as a graph. A codebase-memory server builds a knowledge graph of the repo. Functions, callers, dependencies, cycles. When Claude needs to know what calls processOrder, it queries the graph instead of grepping blind. One tool call replaces dozens of file reads. Search with Tavily for current practice. Before any non-trivial decision I let it search what people are actually doing right now. Training data is old. Best practices from a year ago aren't always still best practices. Clean answer with sources, not a wall of SEO spam. Load Context7 for library docs. Context7 fetches current docs for whatever library I'm about to touch. Anthropic SDK, Next.js, Prisma, whatever. The training cutoff means the model cheerfully invents API methods that got renamed two versions ago. Loading the actual current docs ended that whole category of bug months ago. Now write code. At this point Claude has memory, codebase structure, current ecosystem context, and accurate library docs. The output is dramatically different. Less "let me try this and see", more "based on the call graph and the v5 docs, the change goes here". Hooks are the other piece nobody talks about. The single most important one for me is a read-before-edit guard. It refuses any edit on a file the session hasn't actually read first. Yes, it costs extra tokens up front because the model has to load the file properly instead of guessing what's in it. Those extra tokens are nothing compared to the tokens you burn cleaning up edits that were made blind. Same idea with a safety guard that blocks destructive commands, and a hook that triggers a re-index after edits so the graph stays in sync. And then the loop closes. Whatever worked goes back into memory. Decisions, patterns, traps we hit, fixes that stuck. Next session starts with all of that already loaded. The system gets sharper every week, not because the model changed, but because the context around it keeps compounding. The bigger pattern I figured out over the past few months is that I stopped treating the model as the source of knowledge. The model is the orchestrator. The MCP servers and the hooks are the system. Memory remembers, the graph knows the code, search knows the present, Context7 knows the docs, hooks keep the model honest. The model just connects them. Curious what other people stack before they start a session. Anyone doing this with different servers or hooks? submitted by /u/studiomeyer_io [link] [comments]

I put my SEO workflow to writing winning blog articles into a Claude Code skill so you don't have to figure it out yourself

I condensed my SEO experience into a Claude Code skill that actually does keyword research and writes articles the right way & open sourced it Most AI writing tools I came across gave really shallow output. They go straight from keyword to article with no research in between. No competitor analysis, no understanding of what's already ranking, no reason why someone would read your article over the 10 that already exist. The content always feels hollow because there's nothing behind it. I've been doing SEO long enough to know the research layer is everything. The writing is the easy part. Finding the right keyword, understanding the competitive gap, knowing what angle to take. that's what actually makes content rank So I put my exact workflow into a Claude Code skill. Three slash commands. /blog-onboard - scrapes your site, extracts your business profile, domain rating, ICP, brand voice, and finds your direct competitors automatically /blog-topics - pulls competitor keywords, generates seed phrases based on your ICP pain points, expands them, classifies by funnel stage, clusters into topic groups, scores every keyword by opportunity, picks your first week of articles with titles already generated /blog-write - scrapes the top ranking articles for your keyword, pulls recent news and expert opinions via Tavily, extracts YouTube insights, does SERP gap analysis to find what the current results are missing, generates a full outline, then writes the article in one shot against that outline Everything local, no subscription, just your API keys github.com/maun11/claude-blog-engine It works but there's room to improve. If you've built anything in this space or have opinions on the research layer specifically I'd like to hear it. PRs welcome. submitted by /u/Visible-Mix2149 [link] [comments]

I built a hands-free voice AI that sends emails mid-conversation — and that's just one feature. Here's everything AskSary can do.

https://reddit.com/link/1symbsj/video/k2no3zfgq1yg1/player Been building AskSary solo for a while. Just shipped hands-free voice email - you're mid-conversation with an AI and you say "send an email to [john@example.com](mailto:john@example.com) subject X body Y" and it pre-fills the Gmail modal automatically. One tap sends. Powered by OpenAI Realtime API, works in 22 languages. But that's just the latest feature. Here's the full picture: Every major model in one place GPT-5-Nano, GPT-5.2, GPT-5.2 Pro, O1 Reasoning, Claude Sonnet 4.6, Grok 4, Gemini 2.5 Flash, Gemini 3.1 Pro, Gemini Ultra, DeepSeek V3, DeepSeek R1 - with smart auto-routing or manual override. Pro-Active Personalisation On every login the AI reads your previous conversations and sends the first message itself - asking if you want to continue or start fresh. Before you type a single word. Persistent Cross-Model Memory Start a conversation with Claude on your phone, open your laptop, switch to GPT-5.2 - it already knows what you discussed. No copy-pasting, no summaries. Just works. Knowledge Base - RAG Upload docs up to 500MB per file, unlimited uploads, chat with them across any model via OpenAI Vector Store. Your files stay in context forever. Integrations Google Drive, Gmail, Google Calendar, Notion - access files, get email and calendar summaries, use them in chat or push them to your Knowledge Base. Generation Tools Image Gen - GPT-Image-1 and Nano Banana Pro Flux Image Editor - full editing suite with visual history Video Studio - Luma Dream, Veo 3.1, Kling 1.6 / 2.6 / 3, up to 10 second AI videos with audio Music Studio - 30 second tracks with custom or AI lyrics via ElevenLabs, visualizer built into chat 3D Model Studio - Meshy with STL export (deploying soon) Video Analysis - upload up to 500MB or paste a YouTube link Developer and Builder Tools Vision to Code - screenshot any UI, get live editable code Web Architect - build full web apps from a single prompt Game Engine - build and prototype games with AI Code Lab - split screen live coding with SQL Architect, Bug Buster, Git Guru, Regex Generator, Test Genie and more Tavily web search across all models Voice and Audio Real-time 2-way voice chat - 8 voices, near-zero latency WebRTC Podcast Mode - two AI voices, switchable, near-zero latency, downloadable as MP3 Voiceover Studio, Voice Notes, Voice Tuner Productivity and Content Slides, Docs and File Tools Pro Writer and Content Library Social Tools - Hook Generator, Video Script, Hashtag Creator, Idea Spark Business Suite - Pitch Deck Builder, Deep Analytics, Legal Eagle, Maths Solver Daily Briefing and Market Watch CV Creator, Email Polisher, Cover Letter Builder, TL;DR Bot Share conversations or snippets with anyone Platform Extras 30+ live interactive wallpapers and themes Custom Agents and Personas Folder organisation and Smart Search across chat history Media Manager Gallery - all your generated content in one place Fully customisable UI in 26 languages with full RTL support The Stack Frontend: Next.js, Capacitor (iOS + Android), Vanilla JS / React Backend: Vercel serverless, Firebase / Firestore, Firebase Admin SDK AI: OpenAI, Anthropic, Google, xAI, DeepSeek Generation: Luma AI, Kling via Replicate, Veo via Replicate, ElevenLabs, Flux via Replicate, Meshy Integrations: Google Drive, Notion, Tavily, OpenAI Vector Store, Stripe, CloudConvert, Sentry Rendering: Mermaid, MathJax Platforms: Web, iOS, Android, Apple Vision Pro What you get free just for creating an account (1,000 credits/month, rolling): Unlimited chat on GPT-5 Nano, Gemini Flash and DeepSeek V3 - no daily limits, zero credit charge 25 image generations via GPT-Image-1 and Nano Banana Pro - 40 credits each 8 image edits via Flux Studio - 80 credits each 2 song generations via ElevenLabs - 350 credits each 2 video generations via Luma Dream and Kling - 350 credits each ~70 messages on Claude Sonnet 4.6, GPT-5.2, Grok 4, Gemini 3.1 Pro and DeepSeek R1 - 15 credits each No credit card required. Built entirely solo. No CS degree, no team, no funding. Started because I asked an AI to build me a chatbot and it failed - so I built my own. Accepted to LEAP 2026 in Saudi Arabia along the way. Happy to answer anything about the build. asksary.com submitted by /u/Beneficial-Cow-7408 [link] [comments]

I built a solo AI platform from Bahrain with no funding, no team and no ad spend - here's what's inside it after 4 months

https://reddit.com/link/1sxotqx/video/xlaqd9i8guxg1/player I'm a self-taught developer, 39 years old, based in Bahrain. Four months ago I started building AskSary - a multi-model AI platform with a persistent memory layer that sits above all the models. The core idea: the model is not the identity. Most AI tools lose your context the moment you switch models. I built the layer that remembers you across all of them. Here's what's shipped so far: Models & Routing Every major model in one place - GPT-5.2, Claude Sonnet 4.6, Grok 4, Gemini 3.1 Pro, DeepSeek R1, O1 Reasoning, Gemini Ultra and more - with smart auto-routing or manual override. Memory & Context Persistent cross-model memory. Start with Claude on your phone, switch to GPT on your laptop - it already knows what you discussed. Proactive personalisation that messages you first on login before you've typed a word. Integrations Google Drive and Notion - connect once, pull files and pages directly into chat or your RAG Knowledge Base. Unlimited uploads up to 500MB per file via OpenAI Vector Store. Video Analysis - Gemini native video understanding for YouTube URL analysis (no download required, processed natively) and direct file upload up to 500MB. Full breakdown of visuals, audio, dialogue, editing style and key moments. Generation Image generation and editing, video studio across Luma, Veo and Kling, music generation via ElevenLabs, video analysis via upload or YouTube URL. Builder Tools Vision to Code, Web Architect, Game Engine, Code Lab with SQL Architect, Bug Buster, Git Guru and more. Tavily web search across all models. Voice & Audio Real-time 2-way voice chat at near-zero latency, AI podcast mode downloadable as MP3, Voiceover, Voice Notes, Voice Tuner. Platform Custom agents, 30+ live interactive themes, smart search, media gallery, folder organisation, full RTL support across 26 languages, iOS and Android apps, Apple Vision Pro. Where it is now 129 countries. Currently at 40 new signups a day. 1080 Signup's so far after 4 weeks or so. MRR just started. Zero ad spend. All of it built solo, one feature at a time, on a balcony in Bahrain. The Stack: Frontend - Next.js, Capacitor (iOS and Android) and Vanilla JS / React Backend - Vercel serverless functions, Firebase / Firestore (database + auth) and Firebase Admin SDK AI Models - OpenAI (GPT, GPT-Image-1), Anthropic (Claude), Google (Gemini), xAI (Grok), DeepSeek Generation APIs - Luma AI (video), Kling via Replicate (video), Veo via Replicate (video), ElevenLabs (music), Flux via Replicate (image editing), Meshy (3D — coming soon) Integrations - Google Drive (OAuth 2.0), Notion (OAuth 2.0), Tavily (web search), OpenAI Vector Store (RAG), Stripe (payments), CloudConvert (document conversion), Sentry (error tracking), Formidable (file handling) Rendering - Mermaid (flow charts) and MathJax Platforms - Web, iOS, Android, Apple Vision Pro (visionOS) Languages - 26 UI languages with full RTL support asksary.com Happy to answer questions on any part of the build - stack, architecture, API cost management, anything. submitted by /u/Beneficial-Cow-7408 [link] [comments]

Built an MCP proxy that killed my context bloat AND my RAM usage — here's how

I run pi, VS Code, and sometimes opencode side by side. Each one was spinning up its own complete set of MCP servers (playwright, neo4j, shadcn, searxng, sequential-thinking, next-devtools, tavily, context7, codegraph, you name it). I checked ps aux one day and nearly choked. 35 npm exec processes. ~4 GB of RAM. Just for MCP servers. Three identical fleets, none of them talking to each other. And that's not even the worst part. Every time I started a new agent session, it'd load schemas for all those servers into context again. ~50,000 tokens gone before I typed a single prompt. So I built something to fix both problems at once. What it does It's a lightweight MCP gateway that sits between your AI agents and your upstream MCP servers. Instead of your agent seeing 12 separate servers with 50K tokens of schemas, it sees 6 tools (~375 tokens). That's a 99.3% reduction in context bloat from schema loading alone. The real magic is the HTTP daemon mode. Instead of every pi session or VS Code instance spawning its own fleet of MCP processes, ONE daemon runs all your servers. Every agent connects to it remotely. The numbers: Metric Before After MCP processes ~35 (3 sets) ~10 (1 set) RAM eaten by MCP ~4 GB ~1.3 GB Context tokens on startup ~50,000 ~375 Available system RAM ~1.5 GB ~4.8 GB How it works under the hood: Schema deferral — Your agent searches tools by keyword (gateway.search), loads full schemas only when needed (gateway.describe), and executes through the proxy (gateway.invoke). It never pays for schemas it doesn't use. Response shielding — Big responses get automatically truncated. Arrays over 50 items get capped. Heavy fields get stripped. Everything is paginated so your agent can fetch what it needs without bloating context. Shared daemon — One systemd service runs all upstream MCP servers. pi, VS Code, opencode — they all connect to it via HTTP. No more duplicate processes. What you get: A single ~/.pi/agent/mcp.json or .vscode/mcp.json entry replaces 12+ individual server configs Auto-starts on boot via systemd user service Config hot-reload (edit the config, servers reconnect automatically) Zero changes to your existing workflow — your agent still sees all the same tools The stack: TypeScript, MCP SDK, MiniSearch (BM25), systemd. TL;DR: If you use multiple AI coding agents and MCP servers, you're likely running 3x the processes you need and wasting ~50K tokens on schema loading every session. This gateway cuts both. One daemon, 6 tools, ~375 tokens startup cost. https://github.com/HarshalRathore/harshal-mcp-proxy submitted by /u/Jaded_Jackass [link] [comments]

An AI Equity Research Framework: Design Principles and Setup

I used Claude Code + two MCP tools + a ~400-line protocol file to run deep equity research on Chinese A-share stocks. The workflow starts by enabling Plan Mode, then giving the agent a single instruction: "Follow Deep Research.md strictly, and conduct deep research on [ticker]." This post covers: the core principles behind the protocol design, and the two MCP tools that support it. Note — A-share specific: This setup is built around the Chinese A-share market. The protocol (Deep Research.md) is market-agnostic, but the two MCP tools are not. For US equities, you'll need to swap out ashare-mcp for a different financial data pipeline (SEC EDGAR, a brokerage API, or something like SimFin / Financial Modeling Prep). NotebookLM MCP works as-is for any language. A few other differences worth considering: A-share filings are in Chinese, so your retrieval and parsing tools need to handle that; liquidity and disclosure standards differ; and the grassroots signal sources (Phase 3.5 in the full protocol) will need to be substituted with US equivalents. Part 1: Core Principles The protocol is built around four principles. Each one exists to counter a specific failure mode of LLMs doing open-ended research. 1. Define "Done" Before You Start LLMs are next-token predictors. Without a concrete target, "analyze this company" matches the most statistically common pattern in training data: introduce the company, list metrics, discuss competitive landscape, give a vague conclusion. That output is probable, not useful. The protocol requires a falsifiable research question with a measurable threshold before any retrieval begins — locked in a research contract the agent cannot skip. "CAGR ≥8%" is verifiable. "Decent growth" is not. The agent needs to know what counts as done, or it will optimize for looking like a complete analysis rather than being one. 2. Anchor Hypotheses Before Seeing the Data Once you've read everything, rationalization is easy. The protocol requires the agent to write 3–5 hypotheses and assign prior probabilities to each before any retrieval — and to specify, for each one, what evidence would trigger a revision. Using probabilities rather than just listing hypotheses matters for a specific reason: a list of hypotheses costs nothing — the model can write five and "confirm" all of them. A probability externalizes judgment. Before any evidence arrives, you've committed to a degree of belief for each hypothesis. This forces belief updating to be explicit. If H2 starts at 40% and ends at 40% after a full investigation, that's a finding. If it drops to 15%, that's the conclusion. The prior is the anchor that prevents the model from reading everything and then working backwards to fit the hypotheses to the answer. 3. Grade Claims, Not Just Sources Not all assertions carry the same weight. The protocol classifies every claim into three tiers: C1 (Critical): Revenue, profit, cashflow figures; market share; core thesis; valuation inputs — requires ≥2 independent sources, or must be explicitly flagged as "single source, high uncertainty" C2 (Supporting): Industry trends, event timelines, non-critical comparisons C3 (Background): Definitions and common knowledge "Independent" means different organizations and different data collection methods. Two sell-side analysts citing the same company filing are not two independent sources. Citation drift in practice looks like this: the agent writes "the company holds approximately 35% market share," attaches a link to an analyst report, and all subsequent reasoning builds on that 35% — but that report was itself citing the company's own IR materials, and management's market share definition differs from third-party research firms by 8 percentage points. This rule exists to catch that before it propagates. 4. Isolate the Red Team Confirmation bias in LLMs is structural, not incidental. An agent that built the bull case has its context loaded with supporting reasoning chains. Ask it to challenge itself and its next-token predictions are already anchored toward the thesis it just constructed. The protocol runs a mandatory adversarial review using a separate subagent with a clean context — one that reads only raw data and working notes, never the main report. This subagent must produce ≥3 substantive rebuttals with evidence. The main context then adjudicates each challenge with a formal verdict (accept / partial accept / reject), and "reject" requires ≥2 sourced counter-evidence entries. Context isolation is a structural defense against confirmation bias, not a stylistic choice. Part 2: The Two MCP Tools The principles define what the protocol should do. The tools determine what data it can reach. Both are necessary: a rigorous protocol running on patchwork data will exhaust its context window assembling financials before any analysis begins; abundant data without protocol constraints just produces wrong answers faster and with more confidence. The two

I built a free claude blog skill that actually studies your business, researches competitors & keywords to find winning blog topics and high-quality articles with infographics, internal linking, product promotion, and more...

Most AI writing tools are a fancy wrapper around "give me 1500 words about X." They don't know your business, your competitors, what's already ranking, or why someone would read your article over the 10 that already exist. The output is always that same slightly-hollow, over-structured content that reads like it was written by someone who's never actually done the thing they're writing about. I wanted to build something that approached content strategy the way a good SEO consultant would like studying the business first, doing real research, then writing So I built a set of Claude Code slash commands that run a full pipeline. Here's what it actually does: Step 1: Onboarding Scrapes your website, extracts a structured business profile (product type, ICP, differentiator, brand voice, integrations), then hits DataForSEO's SERP API to find your 3 direct competitors. Everything gets saved locally in .claude/blog-config.json. You run this once. Step 2: Site Intelligence (the interesting one) This is where it gets serious. It runs three keyword sources in parallel: Your existing rankings (top 100 by traffic value from DataForSEO) Competitor keywords (top 200 per competitor) Seed expansion: Claude Haiku generates 30 seed phrases based on your ICP's pain points and integrations, then DataForSEO expands each seed into ~30 related keywords (30 parallel API calls), then bulk KD lookup on all of them That's roughly 2,000 raw keywords before dedup. After merging and deduplicating, it filters by volume floor, KD ceiling relative to your domain rating, and strips anything you already rank top-5 for Then Claude Haiku classifies every remaining keyword into TOFU/MOFU/BOFU in parallel batches of 50. Claude Sonnet groups them into 6–10 topical clusters. Each cluster gets a pillar keyword and supporting keywords. Opportunity scoring uses a weighted additive formula (not multiplicative since it compresses everything toward zero): score = (0.40 × log_volume + 0.40 × difficulty + 0.20 × funnel) × 100 Volume is log-normalized against a 100k anchor so a 1,000/mo keyword scores 60% instead of 1%. 70+ means actually worth targeting. It picks one topic per cluster (breadth-first), generates SEO titles for all 10, and saves them to your content pipeline. Step 3: Content Engine Per article, it runs: DataForSEO advanced SERP for the target keyword → Firecrawl scrapes the top 3 ranking articles to extract H2 structure and avg word count Tavily batch search: 3 queries in parallel for recent news, expert opinions, common mistakes YouTube Data API → transcript extraction via Apify → Claude Haiku pulls 2 concrete insights Then Claude Haiku does SERP gap analysis like what are all 3 top articles covering, what are they missing, what's the best featured snippet opportunity. Claude Sonnet generates a full outline: every H2, H3, word count per section, where research gets placed, where the product mention goes (with specific framing instruction), image positions, CTA matched to funnel stage. Then Claude Sonnet writes the full article in one shot against that outline. Images get generated after Haiku reads the actual written content to create better DALL-E prompts than you'd get from just the keyword. Schema markup and meta assets are separate Haiku calls. Product plug is deliberately constrained: one mention, at a designated section, only after the reader has felt the pain it solves. No marketing language. The outline specifies the exact framing. Output is a folder: article.md (pure content, copy into CMS), publish-kit.md (meta, schema JSON, publishing checklist), and images/. The whole thing is Claude Code slash commands - /blog-onboard, /blog-topics, /blog-write. You run them in any project directory. All data stays local. I open-sourced it here: github.com/maun11/claude-blog-engine It's working but honestly there's a lot of room to improve it. If you've built anything in this space or have opinions on the architecture, would genuinely appreciate the feedback. And if you improve something, PRs are welcome and there's a lot of low-hanging fruit in the pipeline script (scripts/topics_pipeline.py) specifically. submitted by /u/Visible-Mix2149 [link] [comments]

My Claude.md file

This is my Claude.md file, it is the same information for Gemini.md as i use Claude Max and Gemini Ultra. # CLAUDE.md This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. ## Project Overview **Atlas UX** is a full-stack AI receptionist platform for trade businesses (plumbers, salons, HVAC). Lucy answers calls 24/7, books appointments, sends SMS confirmations, and notifies via Slack — for $99/mo. It runs as a web SPA and Electron desktop app, deployed on AWS Lightsail. The project is in Beta with built-in approval workflows and safety guardrails. ## Commands ### Frontend (root directory) ```bash npm run dev # Vite dev server at localhost:5173 npm run build # Production build to ./dist npm run preview # Preview production build npm run electron:dev # Run Electron desktop app npm run electron:build # Build Electron app ``` ### Backend (cd backend/) ```bash npm run dev # tsx watch mode (auto-recompile) npm run build # tsc compile to ./dist npm run start # Start Fastify server (port 8787) npm run worker:engine # Run AI orchestration loop npm run worker:email # Run email sender worker ``` ### Database ```bash docker-compose -f backend/docker-compose.yml up # Local PostgreSQL 16 npx prisma migrate dev # Run migrations npx prisma studio # DB GUI npx prisma db seed # Seed database ``` ### Knowledge Base ```bash cd backend && npm run kb:ingest-agents # Ingest agent docs cd backend && npm run kb:chunk-docs # Chunk KB documents ``` ## Architecture ### Directory Structure - `src/` — React 18 frontend (Vite + TypeScript + Tailwind CSS) - `components/` — Feature components (40+, often 10–70KB each) - `pages/` — Public-facing pages (Landing, Blog, Privacy, Terms, Store) - `lib/` — Client utilities (`api.ts`, `activeTenant.tsx` context) - `core/` — Client-side domain logic (agents, audit, exec, SGL) - `config/` — Email maps, AI personality config - `routes.ts` — All app routes (HashRouter-based) - `backend/src/` — Fastify 5 + TypeScript backend - `routes/` — 30+ route files, all mounted under `/v1` - `core/engine/` — Main AI orchestration engine - `plugins/` — Fastify plugins: `authPlugin`, `tenantPlugin`, `auditPlugin`, `csrfPlugin`, `tenantRateLimit` - `domain/` — Business domain logic (audit, content, ledger) - `services/` — Service layer (`elevenlabs.ts`, `credentialResolver.ts`, etc.) - `tools/` — Tool integrations (Outlook, Slack) - `workers/` — `engineLoop.ts` (ticks every 5s), `emailSender.ts` - `jobs/` — Database-backed job queue - `lib/encryption.ts` — AES-256-GCM encryption for stored credentials - `lib/webSearch.ts` — Multi-provider web search (You.com, Brave, Exa, Tavily, SerpAPI) with randomized rotation - `ai.ts` — AI provider setup (OpenAI, DeepSeek, OpenRouter, Cerebras) - `env.ts` — All environment variable definitions - `backend/prisma/` — Prisma schema (30KB+) and migrations - `electron/` — Electron main process and preload - `Agents/` — Agent configurations and policies - `policies/` — SGL.md (System Governance Language DSL), EXECUTION_CONSTITUTION.md - `workflows/` — Predefined workflow definitions ### Key Architectural Patterns **Multi-Tenancy:** Every DB table has a `tenant_id` FK. The backend's `tenantPlugin` extracts `x-tenant-id` from request headers. **Authentication:** JWT-based via `authPlugin.ts` (HS256, issuer/audience validated). Frontend sends token in Authorization header. Revoked tokens are checked against a `revokedToken` table (fail-closed). Expired revoked tokens are pruned daily. **CSRF Protection:** DB-backed synchronizer token pattern via `csrfPlugin.ts`. Tokens are issued on mutating responses, stored in `oauth_state` with 1-hour TTL, and validated on all state-changing requests. Webhook/callback endpoints are exempt (see `SKIP_PREFIXES` in the plugin). **Audit Trail:** All mutations must be logged to `audit_log` table via `auditPlugin`. Successful GETs and health/polling endpoints are skipped to reduce noise. On DB write failure, audit events fall back to stderr (never lost). Hash chain integrity (SOC 2 CC7.2) via `lib/auditChain.ts`. **Job System:** Async work is queued to the `jobs` DB table (statuses: queued → running → completed/failed). The engine loop picks up jobs periodically. **Engine Loop:** `workers/engineLoop.ts` is a separate Node process that ticks every `ENGINE_TICK_INTERVAL_MS` (default 5000ms). It handles the orchestration of autonomous agent actions. **AI Agents:** Named agents (Atlas=CEO, Binky=CRO, etc.) each have their own email accounts and role definitions. Agent behavior is governed by SGL policies. **Decisions/Approval Workflow:** High-risk actions (recurring charges, spend above `AUTO_SPEND_LIMIT_USD`, risk tier ≥ 2) require a `decision_memo` approval before execution. **Frontend Routing:** Uses `HashRouter` from React Router v7. All routes are defined in `src/routes.ts`. **Code Splitting:** Vite config splits chunks into `react-vendor`, `router`, `ui-vendor`, `charts`. **ElevenLabs Voice Agents:** Lucy's

I spent $0.03 to build a content workflow I thought would cost me hundreds

I'm not a copywriter. Not a marketer. I handle admin stuff at my company and a few days ago I got asked to start prepping social media content. No budget to hire someone, zero experience doing this kind of thing. Claude Code is where most of the real work happens at my job, so I figured there had to be a way to make it work here too. A friend told me to try out Lava, specifically their gateway. Had no clue how it worked tbh, but I connected the Lava MCP to Claude Code and just went for it. Here's what caught me off guard: the moment I connected, I had access to research tools I never signed up for. Exa, Serper, Tavily. No accounts. No API keys. No monthly subscriptions. They were just there through the gateway. My workflow was pretty simple. I had Claude search for trending topics in our industry, give me a take on what actually mattered, and put together a first draft. The output wasn't perfect but it was like 80% there. I looked it over, added some context, tweaked the angle, and had something real to post. Total cost: $0.03. I wanna be clear, I'm not selling anything here. I'm sharing something that happened and worked. For someone in my position (not an expert, no budget, wearing way too many hats), this was kind of a big deal. Not because the content was incredible, but because I could actually do it myself instead of waiting on someone else or spending money we don't have. The thing people miss about automating small workflows like this: it's not just about saving time. It's that it frees you up to focus on stuff that actually needs your brain. Content prep was gonna eat hours every week. Now it doesn't. If you're using Claude Code and haven't tried connecting external tools through an MCP gateway, seriously, give it a shot. The pay-per-use model through Lava meant I didn't have to commit to anything. $0.03 to test whether a workflow works is a pretty solid deal. submitted by /u/Key_Farmer9710 [link] [comments]