I run ArgoCD. Full GitOps — if it’s not in the repo, it doesn’t exist. That’s great for everything except secrets, where “if it’s in the repo, it might not exist for long either.” GitHub secret scanning will catch an API key in a private repo, helpfully disable it, and send you a polite notification that you messed up. So I needed an ESO backend. Here’s what I looked at.

Shopping Around

I was already applying secrets manually via kubectl — which works fine until it doesn’t, and doesn’t scale past “just me doing everything.” The plan was always to wire up External Secrets Operator; the question was just what it would point at.

SOPS came up first — a Claude recommendation. It encrypts secrets in-repo, which sounds elegant, but the decryption key has to live somewhere, and in practice that somewhere is the machine doing the decrypting. If that machine is compromised, the attacker gets the key, and the key opens everything. Security theater. My brain wanted something that felt like AWS Parameter Store — a place secrets live, accessed over an authenticated API, not a place they’re hidden inside something else with the unhiding tool sitting right next to them.

The second AI-generated recommendation was GitHub Actions Secrets. Which, sure — except my IaC repo has GitHub Actions in it. Secrets that live inside the same system they’re deploying feel like a liability waiting to happen. At this point it was clear I needed an actual secrets service, so I started shopping for an ESO backend.

AWS Secrets Manager, AWS Parameter Store, and OCI Vault were the clear, industry-standard options — the real products that do the job properly. But I’m running K3s on a free OCI ARM VM specifically because I want zero dependencies I can’t walk away from. If OCI’s free tier ever goes south, I want to pack up and leave — depending on OCI Vault would chain my secrets to the same cloud I’m trying to stay portable from. And pulling in AWS just for secrets would be adding a second cloud dependency for no reason.

I also stumbled upon Doppler, which I actually liked the look of. The DX is genuinely good, the CLI is pleasant, the UI is clean. Then I hit the pricing page: service accounts — the thing you need for any automated workflow — are a Team plan feature. $21/month per user. For just me. For secrets. No.

Then I found Infisical.

What Infisical Is

Infisical is an open-source secrets manager with a managed cloud offering and a self-hostable option. The cloud tier is genuinely free for reasonable usage. It has a UI, a CLI, SDKs, and first-class Kubernetes support — either via its own operator or as an External Secrets Operator backend, which is what I ended up using.

The Setup I Actually Use: ESO + Infisical Cloud

Rather than the Infisical operator, I went with External Secrets Operator (ESO) using Infisical as the backend. ESO is a CNCF project with a clean abstraction: you define a SecretStore (or ClusterSecretStore) pointing at your secrets backend, then ExternalSecret resources that describe which secrets to sync and where. The output is always a standard Kubernetes Secret. Swap out the backend someday and your app manifests don’t change.

Installing ESO via ArgoCD

I manage everything with ArgoCD, so the ESO install is an Application pointing at the official release manifest:

# applications/external-secrets/kustomization.yml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
  - https://github.com/external-secrets/external-secrets/releases/download/v2.2.0/external-secrets.yaml
  - cluster-secret-stores.yml

The ArgoCD Application itself:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: external-secrets
  namespace: argocd
  annotations:
    argocd.argoproj.io/sync-wave: "-1"
spec:
  project: default
  source:
    repoURL: https://github.com/notjustanna/iac.git
    targetRevision: main
    path: applications/external-secrets
  destination:
    server: https://kubernetes.default.svc
    namespace: external-secrets
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
      - CreateNamespace=true
      - ServerSideApply=true

The sync-wave: "-1" ensures ESO is fully deployed before anything tries to create ExternalSecret resources.

Configuring the ClusterSecretStore

Create a machine identity in Infisical (Project → Access Control → Machine Identities), give it read access to your environment, then store the credentials:

kubectl create secret generic infisical-auth 
  --from-literal=clientId=<your-client-id> 
  --from-literal=clientSecret=<your-client-secret> 
  -n external-secrets

Then the ClusterSecretStore:

# applications/external-secrets/cluster-secret-stores.yml
apiVersion: external-secrets.io/v1
kind: ClusterSecretStore
metadata:
  name: infisical
spec:
  provider:
    infisical:
      auth:
        universalAuthCredentials:
          clientId:
            name: infisical-auth
            namespace: external-secrets
            key: clientId
          clientSecret:
            name: infisical-auth
            namespace: external-secrets
            key: clientSecret
      secretsScope:
        projectSlug: "your-project-slug"
        environmentSlug: "prod"
        secretsPath: "/"
        recursive: true

One ClusterSecretStore serves the whole cluster. Every namespace can reference it.

Consuming Secrets: A Real Example

Here’s how I pull in the Cloudflare API token for Traefik. In Infisical, the secret lives under /traefik. The ExternalSecret syncs everything under that path into a Kubernetes secret in the traefik namespace:

# applications/traefik/external-secret.yml
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: cloudflare-api-token
  namespace: traefik
spec:
  secretStoreRef:
    name: infisical
    kind: ClusterSecretStore
  refreshInterval: 1m
  target:
    name: cloudflare-api-token
    creationPolicy: Owner
    template:
      type: Opaque
  dataFrom:
    - find:
        path: /traefik

Traefik just sees a Kubernetes secret. It has no idea Infisical exists. That’s the whole point.

The Part That Actually Sold Me

The ESO pattern means application manifests don’t change when you change secret backends. Secrets are just Kubernetes secrets to everything downstream — no SDK, no sidecar, no secret-fetching logic in application code. Infisical lives entirely in the infra layer, which is where secrets management should live.

The path-based organization (/traefik, /monitoring, and so on) felt immediately familiar — it’s the same mental model as AWS Parameter Store. That’s not a coincidence; it’s just the right way to organize secrets. The recursive: true on the ClusterSecretStore means ExternalSecret resources can scope as narrowly or broadly as makes sense per workload.

Should You Use the Cloud or Self-Host?

The managed free tier covers up to 5 projects with unlimited secrets. For a homelab or small production workload, there’s genuinely no reason to self-host unless you want to.

If you do want to self-host — the Helm chart is well-documented. Just be aware of the chicken-and-egg problem: if Infisical lives on the same cluster it’s serving secrets to, it becomes a bootstrap dependency, and that gets messy fast. I wrote about this failure mode in more detail here. Infisical Cloud sidesteps it entirely, which is why I’m using it.

Bottom Line

I stopped looking for a better option. Infisical + ESO hit the threshold of “this is clearly correct” — open source, free at the scale I need, Kubernetes-native without being invasive, and not locked to any cloud. The setup I showed above is the whole thing. If you’re still managing secrets via committed files, manual kubectl create secret commands, or CI-only stores — this is the way out.

Cover photo by Sid Verma on Unsplash

I created a new website: Free Access to the 8 Volumes on Typescript & AI Masterclass, no registration required. Choose Volume and chapter on the menu on the left. 160 Chapters and hundreds of quizzes at the end of chapters.

The AI revolution is no longer confined to massive data centers. A new wave of “small language models” (SLMs) is democratizing access to powerful AI, bringing cutting-edge capabilities directly to your laptop, phone, and even web browser. Forget needing expensive GPUs and cloud subscriptions – models like Phi-3, Gemma, and Llama 3 are changing the game. This post explores the theory behind SLMs, how they work, and provides a practical code example to get you started building your own local AI applications.

The Rise of Efficient AI: Why Small Language Models Matter

For a while, the narrative in AI was simple: bigger is better. Large Language Models (LLMs) like GPT-4 demonstrated incredible abilities, but at a significant cost. Running these behemoths requires substantial computing power, making them inaccessible to many developers and everyday users. This created a barrier to entry and limited the potential for widespread AI adoption.

Small Language Models represent a paradigm shift. They prioritize efficiency over sheer size, achieving impressive performance with a fraction of the parameters. This isn’t about sacrificing intelligence; it’s about smarter engineering and innovative training techniques. SLMs are built upon the same foundational Transformer architecture as their larger counterparts, but they’ve been meticulously optimized for speed, reduced memory footprint, and on-device execution. This opens up exciting possibilities for privacy-preserving AI, offline functionality, and real-time applications.

How Do SLMs Achieve High Performance with Fewer Parameters?

The core of SLMs lies in two key strategies: knowledge distillation and architectural optimization.

Knowledge Distillation: Imagine a master chef teaching an apprentice. The master doesn’t just provide the final dish; they explain the nuances of flavor, technique, and ingredient selection. Similarly, knowledge distillation involves training a smaller “student” model to mimic the behavior of a larger, more powerful “teacher” model. The student learns not just what the correct answer is, but why it’s correct, by analyzing the probability distributions generated by the teacher. Phi-3, for example, was trained on high-quality data generated by a larger model, effectively compressing vast knowledge into a compact 3.8 billion parameter package.

Architectural Optimization: SLMs aren’t simply scaled-down versions of LLMs. They employ clever architectural tweaks to improve efficiency. This includes reducing the number of Transformer layers, utilizing techniques like Grouped-Query Attention (GQA) – which reduces computational load by sharing key and value projections – and employing other pruning and quantization methods. GQA, used in Llama 3-8B, is analogous to a web server using a connection pool; it reuses resources instead of creating new ones for every request.

Quantization: The Secret to Running AI on Consumer Hardware

Even with optimized architectures, running SLMs on limited hardware requires further compression. This is where quantization comes in. Traditionally, neural networks use 32-bit floating-point numbers (FP32) for calculations. Quantization reduces this precision to 8-bit integers (INT8) or even 4-bit integers (INT4).

Think of it like compressing an audio file. An uncompressed WAV file is large and pristine, while a high-quality MP3 is significantly smaller with minimal perceptible loss in audio quality. Quantization achieves a similar trade-off: reducing model size and accelerating inference with a negligible impact on performance. A 4-billion parameter model that would normally require 16GB of VRAM in FP32 can run comfortably on a laptop with integrated graphics using INT4 quantization.

The SLM Ecosystem: Local and Browser-Based Inference

The theoretical advancements in SLMs are coupled with practical tools that make them accessible.

• Ollama (Local Inference): Ollama simplifies running LLMs locally. It abstracts away the complexities of model weights, tokenizers, and inference engines, acting as a local API server for AI models. You can interact with SLMs using simple HTTP requests, enjoying zero latency and complete data privacy.
• Transformers.js and ONNX Runtime Web (Browser Inference): Running models directly in the browser is the ultimate edge AI experience. ONNX Runtime Web executes models in the browser using WebAssembly (WASM) for universal CPU execution or WebGPU for GPU acceleration. Transformers.js provides a JavaScript API for downloading, loading, and running ONNX models, making browser-based AI development seamless.

Code Example: Building a Local SLM Chat Interface with TypeScript

Let’s put theory into practice. This example demonstrates a basic web application that interfaces with a local SLM running via Ollama.

// --- Type Definitions ---
type ChatMessage = {
    role: 'user' | 'assistant';
    content: string;
};

interface OllamaGenerateRequest {
    model: string;
    prompt: string;
    stream: boolean;
    options?: {
        temperature?: number;
        num_ctx?: number;
    };
}

interface OllamaResponseChunk {
    response?: string;
    done: boolean;
    context?: number[];
    total_duration?: number;
}

// --- Configuration ---
const CONFIG = {
    OLLAMA_API_URL: 'http://localhost:11434/api/generate',
    DEFAULT_MODEL: 'phi3:mini',
    MAX_RETRIES: 3,
};

// --- State Management ---
const state = {
    chatHistory: [],
    isGenerating: false,
};

// --- DOM Elements ---
const elements = {
    chatContainer: document.getElementById('chat-container') as HTMLDivElement,
    userInput: document.getElementById('user-input') as HTMLTextAreaElement,
    sendButton: document.getElementById('send-button') as HTMLButtonElement,
    statusIndicator: document.getElementById('status') as HTMLSpanElement,
};

// --- Core Logic ---
async function sendPromptToOllama(prompt: string): Promise<void> {
    if (state.isGenerating) return;

    state.isGenerating = true;
    updateUIStatus('Generating...');

    const requestBody: OllamaGenerateRequest = {
        model: CONFIG.DEFAULT_MODEL,
        prompt: prompt,
        stream: true,
        options: {
            temperature: 0.7,
        },
    };

    try {
        const response = await fetch(CONFIG.OLLAMA_API_URL, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(requestBody),
        });

        if (!response.ok) {
            throw new Error(`Ollama API error: ${response.statusText}`);
        }

        const reader = response.body?.getReader();
        if (!reader) throw new Error('No response body');

        const decoder = new TextDecoder();
        let fullResponse = '';

        while (true) {
            const { done, value } = await reader.read();
            if (done) break;

            const chunkText = decoder.decode(value, { stream: true });
            const lines = chunkText.split('n').filter(line => line.trim() !== '');

            for (const line of lines) {
                try {
                    const json: OllamaResponseChunk = JSON.parse(line);
                    if (json.response) {
                        fullResponse += json.response;
                        updateChatDisplay('assistant', fullResponse, true);
                    }
                    if (json.done) {
                        state.chatHistory.push({ role: 'assistant', content: fullResponse });
                        renderChatHistory();
                    }
                } catch (e) {
                    console.warn('Skipped incomplete JSON chunk');
                }
            }
        }
    } catch (error) {
        console.error('Error communicating with Ollama:', error);
        updateChatDisplay('assistant', `Error: ${error.message}`, false);
    } finally {
        state.isGenerating = false;
        updateUIStatus('Ready');
        elements.userInput.disabled = false;
        elements.sendButton.disabled = false;
        elements.userInput.focus();
    }
}

// --- UI Helper Functions ---
function renderChatHistory(): void {
    elements.chatContainer.innerHTML = '';
    state.chatHistory.forEach(msg => {
        const msgDiv = document.createElement('div');
        msgDiv.className = `message ${msg.role}`;
        msgDiv.textContent = msg.content;
        elements.chatContainer.appendChild(msgDiv);
    });
    elements.chatContainer.scrollTop = elements.chatContainer.scrollHeight;
}

function updateChatDisplay(role: 'assistant', content: string, isStreaming: boolean): void {
    let lastMsg = elements.chatContainer.lastElementChild;
    if (isStreaming && lastMsg && lastMsg.classList.contains('assistant')) {
        lastMsg.textContent = content;
    } else if (!isStreaming) {
        const msgDiv = document.createElement('div');
        msgDiv.className = `message ${role}`;
        msgDiv.textContent = content;
        elements.chatContainer.appendChild(msgDiv);
    }
    elements.chatContainer.scrollTop = elements.chatContainer.scrollHeight;
}

function updateUIStatus(status: string): void {
    elements.statusIndicator.textContent = status;
    elements.statusIndicator.style.color = status === 'Generating...' ? '#f59e0b' : '#10b981';
}

// --- Event Listeners ---
elements.sendButton.addEventListener('click', handleSend);
elements.userInput.addEventListener('keydown', (e) => {
    if (e.key === 'Enter' && !e.shiftKey) {
        e.preventDefault();
        handleSend();
    }
});

updateUIStatus('Ready');

The Future is Small: Embracing the SLM Revolution

Small Language Models are not a step back from LLMs; they are a crucial evolution. By prioritizing efficiency and accessibility, they unlock a world of possibilities for AI integration into our daily lives. From on-device assistants to privacy-focused applications, SLMs are paving the way for a more decentralized and democratized AI future. The tools and techniques discussed here provide a solid foundation for exploring this exciting new frontier. Start experimenting with Phi-3, Gemma, and Llama 3 – the power of AI is now within reach, right on your laptop.

The concepts and code demonstrated here are drawn directly from the comprehensive roadmap laid out in the book The Edge of AI. Local LLMs (Ollama), Transformers.js, WebGPU, and Performance Optimization Amazon Link of the AI with JavaScript & TypeScript Series.
The ebook is also on Leanpub.com: https://leanpub.com/EdgeOfAIJavaScriptTypeScript.

👉 Free Access now to the TypeScript & AI Series on Programming Central, it includes 8 Volumes, 160 Chapters and hundreds of quizzes for every chapter.

The Problem Nobody Is Solving

There are over 1 million autonomous AI agents active today. Each one has cognitive capacity that — while its owner sleeps, works, or has not assigned a task — sits idle. Wasted. Generating cost without generating value.

At the same time, other agents are executing complex tasks and need additional capacity. They need specialized analysis. They need to subcontract reasoning. They need access to agents with specific context they do not have.

Today, when an agent needs another agent, it has two options: struggle alone, or stop and wait for a human.

Both options are inefficient. Both limit what the agent economy can achieve.

That is the problem. OIXA is the infrastructure that solves it.

How OIXA Works

1. Registry (ERC-8004)

Agents publish an Agent Card: capabilities, models, price, and current availability. Updated in real-time. Other agents can query the registry to find exactly the capacity they need.

2. Reverse Auction

A buying agent posts an RFI (Request for Intelligence): the exact prompt, required model, max budget. OIXA notifies compatible agents. A reverse auction opens — sellers compete downward. The market discovers the real price.

Auction timing is dynamic:

• $0.001–$0.10 → 1–2 seconds
• $0.10–$10 → 3–5 seconds
• $10–$1,000 → 10–30 seconds

3. Stake System (Anti-Sybil)

Every bidder deposits 20% of their bid as stake. No stake, no bid. This makes flooding the market with fake identities economically impossible.

4. Automatic Verification

OIXA verifies the output cryptographically: right model, delivery time met, coherent result. If it passes → escrow releases in USDC automatically.

5. Public Ledger

Every transaction is recorded immutably. Behavior is public. Content is private. Reputation is built on real data.

The Stack

LOGIC    → Off-chain (fast, efficient)
FUNDS    → On-chain via Base + USDC (trustless)
REGISTRY → On-chain via ERC-8004 (permanent)
PAYMENT  → x402 Protocol (autonomous)
COMMS    → A2A + MCP (standard)

Why This Is Different

The A2A Economy Is Already Happening

Agent-to-agent commerce is not a future concept. It is happening today — informally, unreliably, without economic guarantees. Agents call other agents via APIs. They chain tasks. They subcontract.

OIXA makes this trustless. Autonomous. Paid.

Like HTTP defined how computers communicate on the internet, OIXA defines how agents discover, hire, verify, and pay each other. Anyone can build on it. No permission required.

Where We Are

Phase 0 — Foundation: whitepaper published, protocol server running, GitHub live, community growing.

Phase 1 (next): first 100 agents connected, first real transactions on Base mainnet.

GitHub: https://github.com/ivoshemi-sys/oixa-protocol
Community: https://t.me/oixaprotocol_ai
Whitepaper: https://github.com/ivoshemi-sys/oixa-protocol/blob/main/WHITEPAPER.md

The agent economy needs infrastructure. We are building it.

Your Obsidian vault is your second brain. Years of notes, project plans, daily journals, meeting records, research — all connected with wikilinks and tags in a carefully organized folder of Markdown files.

But your AI can’t see any of it. You copy-paste snippets into ChatGPT. You describe your note structure to Claude. You manually relay information between your knowledge base and your AI.

That ends now. MCPBundles provides an Obsidian MCP bundle — 35 tools that give your AI full read/write access to your vault through the Model Context Protocol. It’s a standard MCP server — the tools show up natively in whatever AI you already use. Claude Desktop, ChatGPT, Cursor, Windsurf, the mcpbundles CLI, or any MCP-compatible client.

35 tools. Your AI becomes an Obsidian power user.

The Obsidian MCP bundle gives your AI the same access to your vault that you have — and then some. It reads notes and gets back structured data — parsed frontmatter, tags, file stats — not just raw text. It browses your folder hierarchy. It searches across every note in your vault with relevance scoring, regex patterns, frontmatter queries, and date ranges.

It writes. Not just “dump a whole file” writing. Your AI can create notes with full frontmatter, append entries to existing notes, and — this is the part that matters — surgically edit specific sections of a document without touching anything else.

It sees your images. It analyzes your graph structure. It finds orphaned notes and broken links. It lists every task across your entire vault.

Surgical edits change everything

Most integrations that touch files do the same thing: read the whole file, modify it in memory, overwrite the whole file. Fine for code. Terrible for a living document with dozens of sections, tasks, and metadata fields that you don’t want an AI to accidentally mangle.

The Obsidian PATCH operation works differently. Your AI targets a specific heading, block reference, or frontmatter field and inserts, replaces, or appends content just there.

Say you’ve got a project plan with milestones, discussion notes, and action items. You tell your AI to add two items to the milestones section. It reads the document map (a lightweight call that returns all headings, block refs, and frontmatter fields), finds the right heading, and appends only to that section. Your discussion notes and action items stay exactly as they were.

The same precision works for frontmatter. Your AI can flip status: draft to status: shipped on a single field without rewriting the YAML block. It can add a new reviewer: Tony field that didn’t exist before. It can target nested heading paths like "Launch Plan::Key Milestones" to reach the right section in a deeply structured document.

This is the difference between an AI that can edit text files and an AI that understands Obsidian’s document structure.

Daily notes are the fast path

The most common Obsidian workflow is appending to today’s daily note. A quick thought, a task, a meeting summary — you open today’s note and add a line.

Your AI does the same thing in one call. No need to figure out today’s date, construct the filename, check if the file exists. Just “append this to my daily note.” It handles the rest, including creating the note if it doesn’t exist yet.

This turns your AI into a persistent journal. Every conversation can leave a trace in your vault. Meeting summaries go into the daily note. Research findings get filed in project notes. Action items land where they belong.

Your AI can see your images

When your AI reads an image from your vault, it doesn’t get a file path or a base64 blob dumped into a text response. It gets the actual image as an MCP ImageContent block — the same way a screenshot tool returns visual content.

That means any AI model with vision — Claude, GPT-4o, Gemini — actually sees the image. Your AI can describe a diagram, read handwritten notes from a photo, interpret a screenshot, or analyze a chart. All from files already sitting in your vault.

PNG, JPEG, GIF, WebP, BMP, and SVG are all supported. The image flows through the same proxy tunnel as everything else — nothing gets stored on MCPBundles servers.

Graph analysis and vault maintenance

Obsidian’s power comes from connections between notes. Wikilinks turn a folder of Markdown files into a knowledge graph. But maintaining that graph — finding orphans, fixing broken links, understanding relationships — is manual work.

Your AI traverses your link graph. Graph neighbors does a breadth-first search from any note, finding every connected note within a configurable depth. Direction matters: outgoing links, incoming backlinks, or both.

Orphan detection scans every note in your vault and identifies the ones with zero incoming wikilinks — notes that nothing else links to. These are the ones you forgot about, the stubs you never connected, the ideas that fell through the cracks.

Broken link detection scans every wikilink in every note and checks whether the target actually exists. That reference to [[Old Project Name]] you renamed three months ago? Found.

Task management across your entire vault

Obsidian is great for tasks — the checkbox syntax (- [ ] do the thing) works in any note. But there’s no built-in way to see tasks across your entire vault. Your AI can.

The task listing tool scans every note, extracts every checkbox, and returns them with their source file and line number. Filter by status (open, completed, all), by folder, by tag, or by keyword. Ask your AI “what are my open tasks tagged with Q2?” and get an answer without installing any plugins.

How the proxy tunnel works

Obsidian runs on your desktop. AI services run in the cloud. The MCPBundles desktop proxy bridges them with an encrypted tunnel.

AI → MCPBundles → Proxy Tunnel → Your Desktop → Obsidian (localhost:27124)

Your vault data flows through the tunnel in real time. Nothing gets stored on MCPBundles servers. The proxy handles Obsidian’s self-signed TLS certificate automatically.

Works with the AI you already use

MCPBundles is a remote MCP server. You connect it once and the Obsidian tools appear in your AI’s tool list — alongside any other bundles you’ve enabled.

Claude Desktop, ChatGPT, Cursor, Windsurf — add the MCPBundles MCP server URL and the tools are there.

mcpbundles CLI — for terminal workflows, scripting, and automation. pip install mcpbundles and you’re set.

Any MCP-compatible client — if it speaks MCP, it works. The tools are standard MCP tools with proper schemas, annotations, and content types.

Five minutes to set up

1. Install the Obsidian plugin

Install the Local REST API community plugin in Obsidian (by Adam Coddington). Enable it and copy the API key from the plugin settings.

2. Start the proxy

pip install mcpbundles
mcpbundles login
mcpbundles proxy start

3. Enable the bundle

Go to MCPBundles, enable the Obsidian bundle, and paste your API key. The 35 tools are now available to every AI client connected to your MCPBundles server.

What this looks like in practice

You’re prepping for a team meeting. You tell your AI: “Create meeting notes for the Q2 planning sync with attendees Tony and Sarah, agenda: hiring, roadmap, budget.” A fully structured note appears in your vault with frontmatter, sections, and wikilinks to related project notes.

After the meeting, you tell your AI to append the action items. It doesn’t overwrite your agenda — it surgically appends to the action items section.

Later, you ask your AI to search your vault for everything related to “database migration.” It finds four notes across different projects, reads them, and creates a consolidated summary note linking back to the originals.

You photographed a whiteboard and dropped the image into your vault. Your AI sees the photo, reads the sticky notes, and creates structured tasks in a new project note.

Your vault has grown to 500 notes. You ask your AI to run a health check. It finds 23 orphaned notes, 7 broken wikilinks, and 45 open tasks scattered across 12 files. It creates a maintenance summary with links to every issue.

None of this requires you to leave your AI chat.

Get started

pip install mcpbundles
mcpbundles login
mcpbundles proxy start

Enable the Obsidian bundle, add your API key, and start talking to your vault.

MCPBundles is a hosted platform for connecting AI agents to real third-party services via the Model Context Protocol. 60+ bundles, 1900+ tools — Stripe, HubSpot, Postgres, Gmail, Obsidian, and more. Get started free.