Generate SEO Content Directly from Your LLM: The Complete Wisewand MCP Guide

You already use an LLM to write, research and structure. This guide asks a narrower and more useful question: how do you hand it a complete content production chain, from creating an article to publishing it on your site, and how do you do the same thing with no LLM at all when you just want a machine to handle it at six in the morning.

Everything here was read first-hand from the published package: the counts, the commands, the exit codes and the behaviours described below were checked by querying the binary, not by copying a documentation page.

What is Wisewand MCP?

The Model Context Protocol is an open standard introduced by Anthropic. It defines how a model discovers external tools, reads their description, fills their parameters and interprets their answer. In practice: you do not click and you do not paste, you ask. The model picks the tool.

The Wisewand server is that standard implemented on top of the Wisewand API, the one already running the app. And here is the point that governs the rest of this guide: the package is not only the server. It also ships a terminal command, which exposes the same thing with no LLM in the loop.

The 4 prompts (onboarding_wizard, blog_post_wizard, content_campaign, seo_optimization) are served by the server itself. In other words, the onboarding walkthrough is not something to install: you ask your LLM to use the onboarding wizard, and it guides you.

Why this changes everything

Five content types are covered, and each has a full cycle from creation to publication.

On the publishing side, four platforms plus one generic outlet: WordPress, Shopify, WooCommerce, PrestaShop, and a webhook for everything else. If your site runs on WordPress, the WordPress connector and the Shopify connection each have their own page.

Language and country are chosen article by article: the tool schema accepts 83 language codes and 239 country codes, which are Google's hl and gl parameters. These are not translations: it is the same tool, tuned for a market.

None of this guarantees a Google position or a citation by an answer engine. What it changes is the unit cost of a clean publication and the number of contexts you have to keep in your head.

Three doors to the same 89 tools

Why the CLI is often the best choice

The moment you step out of the conversation, the command is the shortest path. Four reasons, all design facts rather than arguments.

1. The output adapts on its own. A readable table when the output is a terminal, JSON as soon as it is redirected or piped. So | jq works with no flag at all. In a script you still pin it with --json, --table or --markdown, so you do not depend on the execution context.
2. Logs never pollute the output. Progress and debug messages go to stderr, always. So wisewand articles list > out.json produces a clean file. NO_COLOR is honoured.
3. Seven exit codes, one of them dedicated to rate limiting. A cron job becomes scriptable without parsing error text.
4. The same registry. The CLI is not a rewrite of the API: it is the second projection of the same tool registry, and its flags are derived from each tool's JSON Schema. That is what makes drift between the two doors mechanically impossible.

wisewand articles create "How to brew coffee" --lang en --length 1200
wisewand articles list --json | jq '.items[].id'

Installation and configuration

Installing the MCP server takes three moves: get a key, declare the server to your client, check that the tools are there.

Step 1: get your API key

Create or open your account, then copy the key shown on the API access page.

• Go to app.wisewand.ai/api.
• Copy the key: it starts with sk_live_ in production, sk_test_ in test.
• Keep it handy, the next step needs it.

Step 2: install the MCP servers

Declare the server to your MCP client, using the key from the previous step.

With Claude Code, one command is enough, and it asks no questions:

claude mcp add -e WISEWAND_API_KEY=sk_live_YOUR_KEY wisewand -- npx -y @wisewandtools/mcp-server

The -- separator is mandatory: it separates the options of claude mcp add from the command that actually launches the server. Without it, npx and its arguments are read as options of claude.

There is a cleaner variant, and it is the one we recommend. Install the package first, store the key once with the CLI, then declare the server with no key on the command line:

npm install -g @wisewandtools/mcp-server
wisewand login
claude mcp add wisewand -- npx -y @wisewandtools/mcp-server

The benefit is concrete: the key never enters your shell history, nor the machine's process list.

The complete configuration file, reusable as-is for the last four clients, is given at the end of this guide.

Step 3: verify the installation

Open a new session and ask your LLM to list the available Wisewand tools.

You should see 89. A different count means the client loaded another version of the server, or a second colliding entry. The server also writes its inventory to stderr at startup, as {"tools":89,"resources":6,"prompts":4}: that is the binary counting, not a human.

API key security best practices

An sk_live_ key gives full access to your account and your credits. Three habits cover the essentials.

• Prefer wisewand login to a key on the command line. It is then stored in ~/.wisewand/config.json, a file with 600 permissions inside a 700 directory. The CLI warns you if it finds it more permissive.
• The --api-key flag is visible in the process list. The command's own help says so. Keep it for one-off tests.
• Never commit an MCP configuration file. Add .mcp.json to your .gitignore.

Where exactly should I paste my API key?

It depends on the door. The CLI reads the key from four places, in this order of priority; the MCP server reads only three: the .env file in the current directory does not concern it.

One design detail is worth knowing: when the key is malformed, the error message names the source it came from. So there is always exactly one place to go and fix it.

Which client should I use?

The one you already work in. The 89 tools are identical across clients because they come from the same server: the client only carries them. If you have no preference, Claude Code has the shortest install, one command and no file to edit.

And if your need is not conversational, do not pick a client at all: go straight to the wisewand command described below.

Global or project-level: which should I pick?

Project-level when the content you produce belongs to a specific repository, with its own key and its own scripts. Global when you use it as a personal tool, in any folder.

The criterion that actually decides: a project-level declaration travels with the repository, so it also travels to your colleagues and your CI. That is an advantage as long as the key is not in the file, and a problem the moment it is. Hence the recommendation in step 2.

Need help?

The onboarding wizard is served by the server itself: ask your LLM to use the onboarding wizard and it walks you through the 89 tools, a first article step by step and five real workflows, in about ten minutes.

For everything else, the address is [email protected].

The wisewand CLI, in detail

Install and authenticate

npm install -g @wisewandtools/mcp-server

wisewand setup     # guided walkthrough: key, project, persona, publishing connection
wisewand login     # or just the key, stored in ~/.wisewand/config.json
wisewand whoami    # which source answered
wisewand logout

Two details are worth writing down. setup asks before writing anything, it changes nothing behind your back. And whoami is first and foremost a diagnostic command: when several key sources coexist, it is the one that tells you which was picked.

The general shape: resource, then verb

The CLI's 14 resource groups are exactly the server's 14 tool families, plus a few meta-commands. They are not hardcoded in the binary: they are generated from the registry, which is the mechanical reason the two doors cannot drift apart.

The universal escape hatch: wisewand call

Every tool stays reachable by its MCP name, whatever CLI verb exposes it:

wisewand call create_article --input brief.json
cat brief.json | wisewand call create_article --input -

This is the stable scripting interface: tool names do not move, so a script that goes through call survives a change of CLI verb.

Explore the registry without documentation

Two commands answer « what tools exist » and « what parameters does this one take ». Neither costs credits, and tools does not even need a key: it reads the registry embedded in the package.

wisewand tools --search discover
wisewand tools describe create_article

Here is the real output of the first command, truncated to its four first entries. Note that it is JSON: the output was piped, so the CLI switched on its own.

[
  {
    "name": "discover_content",
    "command": "discover create",
    "description": "Create a Google Discover article, written for the Discover feed rather than for search. Only `subject` is required."
  },
  {
    "name": "run_discovery",
    "command": "discover run",
    "description": "Generate the content of an existing discover article."
  },
  {
    "name": "get_discover_result",
    "command": "discover get",
    "description": "Get a discover article's details and status."
  },
  {
    "name": "list_discover_articles",
    "command": "discover list",
    "description": "List and search discover articles."
  },
  ...
]

The 95-property problem

create_article accepts 95 properties, and exactly one is required: subject. Everything else inherits from the project brief when you omit it. The inline help only shows a small subset, and hides the rest, which works anyway. It says so explicitly on its last line:

84 more options are available. Run wisewand tools describe create_article for the full schema, or pass a complete payload with --input <file>.

For anything substantial, the right answer is therefore a file:

wisewand articles create --input brief.json --lang en

One rule to remember: explicit flags beat the file. Above, --lang en overrides the language declared in brief.json. That is what lets you keep one brief and decline it per market.

The seven exit codes

This is what makes a scheduled job genuinely scriptable: your script decides on an integer, never by parsing an error message.

Wait, or hand back control

By default, generate waits for the generation to finish. Two flags change that, and they map to two different use cases.

Your first article: a real conversation

Here is what the exchange looks like, on the conversation side.

You: « Create an SEO article about the best AI tools for content creation. »

The LLM: uses create_article. Article created, id abc-123. Target keyword, FAQ section, table of contents and lead image all come from the project brief.

You: « Show me the content when it is ready. »

The LLM: uses get_article then get_article_output. Done. Here are the title, the description and the body.

The same thing, as one command, with no LLM:

wisewand articles write "The best AI tools for content creation" --project <project-id>

articles write is the CLI's only composed workflow: it creates, generates and prints the result, three steps in one.

The most counter-intuitive fact about the product

Creating an article already starts its generation. There is nothing to trigger afterwards. The command's own help says it, unambiguously:

Creating queues the generation, and that costs credits. The entity goes prequeued to queued to running to success on its own; nothing has to call generate_article.

Someone unaware of this calls generate_article believing they are starting the work, when in fact they are restarting it. The right reflex is therefore the opposite of the intuition: after create, you poll, you do not re-trigger.

The useful corollary, worth knowing before you pay for a mistake: to price a job without launching it, there is estimate_article_cost, which takes exactly the same request body and consumes nothing.

The perfect 7-step workflow

Installation gives you the tools. What follows gives you a system: a persona that holds the voice, a project that holds the brief, a connection that holds the publishing. Once that is in place, an article takes one sentence.

Step 1: download and install

This is step 2 of the previous section, nothing more. Once the server is declared, restart your client so it loads it.

Step 2: verify the API key

Ask for the tool list: you should see 89. From a terminal, wisewand whoami answers the same question and additionally tells you which key was picked, which is half the diagnosis when several sources coexist.

Step 3: configure the website connection

To publish to WordPress, create an application password from your WordPress profile, never your main password. It is revoked independently, which lets you cut Wisewand's access without touching your account.

• In WordPress: Users, then Profile, then the Application Passwords section.
• Name it clearly, for instance Wisewand, and copy it right away: it is shown only once.
• Then create the connection with create_connection, or wisewand connections create.

WordPress stays optional. Wisewand produces content you can collect and publish wherever you like; the connection only removes the copy step.

Step 4: create your persona

A persona is two things: the style, meaning how it writes, and the resume, meaning who is writing. That is what stops twenty articles generated on the same day from all sounding alike.

Create as many as you have registers, test one on a single article before launching a series, then reuse it.

Step 5: create a project and set up the brief

A project carries the brief every generation inherits: language, country, default persona, publishing connection. It is the piece that does the most work in the system.

The direct consequence is good news: the fuller your brief, the shorter your commands. Of the 95 properties on create_article, only subject is required, everything else falls out of the project.

Step 6 (optional): connect Haloscan MCP

A second MCP server is declared exactly like the first, and your LLM combines them without you having to coordinate anything. Haloscan covers keyword research and competitive analysis, where Wisewand covers production and publishing.

claude mcp add haloscan -e HALOSCAN_API_KEY=YOUR_KEY -- npx -y @occirank/haloscan-server@latest start

The sequence becomes: ask which keywords to target, choose, then ask for the article on the one you picked. Two servers, one conversation.

Step 6b (optional): connect Google Search Console MCP

The third angle is your own data: clicks, impressions, average position, indexing status. Haloscan says what the market searches for, Search Console says what your site already gets, Wisewand produces.

This server needs a Google OAuth setup, so it takes longer to install than the other two. It becomes worth it as soon as you have enough pages for the question « which one do I refresh first » to arise.

Step 7: create your perfect article

With the previous six steps in place, an article fits in one sentence, because all the context already lives in the project and the persona.

wisewand articles write "How to choose a bean-to-cup coffee machine" --project <id>
wisewand publish wordpress --id <article-id>

And if you would rather read before publishing, slip wisewand articles output --id <id> --markdown in between. That is in fact what we recommend: generate, read, publish.

The complete toolbox: 89 tools explained

The pattern that saves you reading everything

Five families (articles, discover, update-posts, category-pages, product-pages) carry exactly the same ten verbs. Learn them once and you have them all.

Articles

Write, generate and export articles. create_article only requires subject: everything else inherits from the project.

bulk_estimate_cost deserves to be known: it is the way to price 50 creations without running a single one.

Projects

A project carries the brief every generation inherits, the publishing connection and the defaults. It is also where unattended production is switched on, by setting autopilot to true on the project.

Autopilot

Unattended content production. A single read, because the settings live on the project and not here.

Personas

The voice. A persona is a style, how it writes, plus a resume, who it is.

Content discovery

Content written for the Google Discover feed rather than for search, and drafts derived from search results. This is the family whose generation verb is called run.

Article updates

Reworking content that is already published, without changing its URL. Same ten verbs as articles.

Category pages

The collection pages of an e-commerce site, the ones that catch broad queries.

Product pages

Product write-ups, with comparisons, selling points and affiliate links.

Publishing

Four platforms, a generic webhook, and one read that is worth its weight when something does not show up.

get_publish_errors answers « the content generated fine, but it never appeared on the site ». It is the first place to look.

Connections

Your platform credentials, plus three Shopify-specific tools.

get_shopify_internal_link_targets finds the products, collections and blog articles in a Shopify store that are relevant to a topic. That is what lets new content point at your existing catalogue instead of standing alone.

RSS feeds

Feed management, to drive production from an external source.

Background jobs

Inspect and re-trigger a job. Useful when a long generation deserves to be watched from outside.

Credits and billing

Your consumption history, overall and day by day.

Account

Your account's reference data: authors, categories, and the usage summary.

The traps: what the API does, not what you assume

Retries: a read is replayed, a write is not

This is the single most important behaviour of the product for anyone automating it, and it fits in one sentence: a read is replayed, a write is not. With one exception, rate limiting.

The reasoning is this, and it holds. Rate limiting is the only failure that tells you what the server did, namely nothing: replaying it is risk-free. A 500, a timeout and a dropped connection are, from the client's point of view, indistinguishable: the write may have completed entirely before the answer was lost.

This rule comes from a real incident. Before version 3.1.0, every method was retried three times, and a single publish call produced four requests against a user's WordPress site, 2, 4 and 6 seconds apart. Applied to an article creation, a timeout could have created four articles and billed four times.

Instead, the client raises an error that names the read that settles it:

This POST was not retried: the API may have carried it out before the failure, so sending it again could do the work twice. Check with list_articles before retrying.

And there is no setting to turn the write side back on. The retry variables only govern reads.

Polling: why a 60-second timeout does not cap a 3-minute generation

A generation call does not open a long request. It starts the generation, then polls the status every 5 seconds until it finishes or until the maximum wait you set.

The consequence is not obvious: the per-request timeout, 60 seconds by default, does not bound a three-minute generation, because that generation is made of N short requests and not one long one. Raising it only helps if a single request exceeds a minute, which is rare: that 60-second default is thirty times the slowest response ever measured against the API.

The response format: there is no envelope

Every tool returns a text block containing JSON. There is no common envelope, and in particular no data key to unwrap. A list returns items, count and total. An error carries error, message and hint.

Three more traps, quieter but time-consuming.

• Markdown is a one-way trip. The API stores HTML, and format: "markdown" converts on the way out. But the output-update tool writes HTML. It is a reading format, not an exchange format.
• Entity reads are minimal. get_article, get_category_page and get_product_page typically return an id and a status. The content is read through the matching output tool.
• Rate limiting is a global bucket, not a per-client one. And there is one client per process, because the MCP transport is a pipe. Two open sessions therefore share the same 60 requests per minute.

How the package verifies itself

An engineering detail that explains why the tool descriptions are trustworthy: the schemas are not written by hand, they are generated from the OpenAPI specification. That specification carries 83 languages, 239 countries, 99 content properties and 88 operations.

The reason is instructive. The API declares additionalProperties: true, so a field sent under a name it does not know is accepted and then discarded. One call once sent six non-existent field names, got an HTTP 200, created an empty project and reported success. Neither the typing, nor the API, nor the tests said a word.

Hence a verification pass that calls all 88 operations against the real API, with real keys and real credits, and reads every write back to tell « stored » from « swallowed ». The latest pass gives 81 operations verified, 1 failure and 6 unverifiable for want of a test store on the platforms concerned.

Real-world use cases

Four complete workflows, each expressed through both doors: the sentence you would say to an LLM, and the command you would put in a script.

a) SEO blog series

Goal: produce a series of related articles on one theme, with coherent internal linking.

Bulk creation exists precisely for this, and its bulk estimate lets you know the total cost before anything is launched.

wisewand articles bulk-estimate --input series.json   # the quote
wisewand articles bulk-create   --input series.json   # the order

The series.json file carries the list of subjects; everything else, language, persona, length, FAQ, table of contents, comes from the project brief.

b) Product review site

Goal: product write-ups and comparisons with affiliate links, over a catalogue that keeps moving.

This is the ground of product pages and category pages. The schema explicitly provides for both affiliate shapes: the single-product review, and the two-product comparison, each with its links and its reference review URLs.

On a Shopify store, add get_shopify_internal_link_targets: it finds the products and collections relevant to the topic, which lets the write-up point at your catalogue instead of standing alone.

c) Multi-language expansion

Goal: the same subject, declined for several markets, with search settings adapted to each.

One brief, one file, and the market goes in a flag. Remember that an explicit flag beats the file: that is exactly what makes this loop possible.

for market in "en:us" "en:uk" "es:es"; do
  wisewand articles create --input brief.json \
    --lang "${market%%:*}" --country "${market##*:}"
done

Mind the United Kingdom code: it is uk, never gb.

e) Content refresh campaign

Goal: rework older articles without changing their URLs.

That is the update-posts family, and it is probably the best effort-to-result ratio once you already have a stock of pages. An article with age and inbound links starts from higher ground than a brand-new page.

The right order: list what exists, choose on real data rather than on intuition, estimate, then launch. A Search Console MCP server alongside turns « choose » into a documented decision.

Advanced tips and best practices

SEO optimization

Put the maximum in the project brief, the minimum in the command. This is the advice with the most effect over time: a full brief makes your commands short, reproducible and consistent with one another. The schema is built for it, since subject is the only required field out of 95.

Enable the FAQ and the table of contents on long formats. They structure the page into self-contained passages, which is useful to readers and readable by answer engines.

Do not aim at a single query. Secondary keywords exist in the schema; filling them widens the coverage of one article without writing a second. If you want to dig into visibility inside generated answers, we have given it a dedicated page on SEO and GEO.

Publishing strategy

Generate, read, publish. In that order, with a human in the middle step. The CLI makes that discipline easy: articles output --markdown hands you readable text in one command.

Check your platform's default. Shopify publishes live, WordPress creates a draft. If you want the same behaviour everywhere, pass the status explicitly rather than relying on the default.

Handle the exit codes. In a cron job, a code 5 means « try again later » and a code 3 means « your key is dead, tell someone ». Those are not the same consequences, and telling them apart costs two lines of script.

Image generation

Images are configured in the brief like everything else. Two useful habits.

Pick the ratio for the destination, not by default: 16:9 for a featured image, 1:1 for social, 9:16 for vertical formats.

Price before running a series. Images count towards the cost, and the estimate tool takes exactly the same parameters as creation. On a bulk order, the quote takes one command and costs nothing.

Frequently asked questions

Do I need Claude Desktop or the Claude Code CLI?

No. Any MCP client will do, and the features are identical because they come from the same server: Claude Code, Claude Desktop, Cursor, VS Code and Windsurf are all covered. You can even skip the MCP client entirely by using the wisewand command, which exposes the same 89 tools from a terminal.

Can I use it without an LLM at all?

Yes, and it is often the better choice. The wisewand command ships in the same npm package as the MCP server and reaches the same 89 tools, with no MCP client and no model. It is the door to use for a scheduled job, a deployment script or a CI pipeline, where the output must be deterministic and the return code machine-readable.

What happens if a call fails?

It depends on what the call was doing. A read is retried automatically, across all four failure families. A write is only retried on rate limiting, never on a server error, a timeout or a dropped connection, because in those three cases the client cannot know whether the write went through before the answer was lost. The error message then names the read you should make to settle it. There is no idempotency key: the check stays on you.

What should I do if I get the « Cannot connect to Wisewand API » error?

First check the key's shape, which must start with sk_live_ or sk_test_, and that it was copied in full. Remember that the server only validates the shape at startup: a well-formed but revoked key only shows up on the first call, as a 401. From a terminal, wisewand whoami tells you which source supplied the key that was picked, which settles most cases where several sources coexist.

Can I use this tool without WordPress?

Yes. Direct publishing covers WordPress, Shopify, WooCommerce and PrestaShop, plus a generic webhook for everything else, but nothing forces you to use it. You can collect the generated content with the output tool, in HTML or Markdown, and publish it wherever you like. The connection only removes the copy step.

How long does article generation take?

Creation is near-instant, about a second, and generation takes 30 to 180 seconds depending on length and number of images. Mind the counter-intuitive point: creation already queues the generation, there is nothing to trigger afterwards. The entity moves on its own from prequeued to queued, then running, then success, while the client polls it every five seconds.

Can I customize the writing style?

Yes, that is what personas are for. A persona combines a style, describing how it writes, and a resume, describing who is writing. You can create as many as you have registers and set the default one at project level. The right habit is to test one on a single article before launching a series.

Which languages are supported?

The tool schema accepts 83 language codes and 239 country codes. These are Google's hl and gl parameters, not ISO codes, which explains two frequent surprises: the United Kingdom is written uk and not gb, and Portuguese does not exist as bare pt, it has to be pt-PT or pt-BR. Language and country are set at project level and overridden article by article.

What is the cost per article?

Budget roughly 10 to 20 credits for a 1000-word post, plus 5 to 10 with images and 2 to 5 with social posts. These are orders of magnitude: the exact figure is knowable in advance through the estimate tool, which takes exactly the same parameters as creation and consumes nothing. For a bulk order, the bulk estimate prices the whole batch before anything is launched.

Can I track my usage?

Yes, through three complementary tools: get_usage_summary for the overview, list_transactions for the detailed history and get_daily_transactions for day-by-day consumption. From a terminal those are wisewand account usage, wisewand transactions list and wisewand transactions daily.

Can I connect multiple WordPress sites?

Yes. Create one connection per site, with its own credentials and an explicit name, then attach the connection to the matching project. That is what lets an agency cleanly separate several clients, each with its brief, its persona and its publishing destination.

Is it compatible with Shopify and WooCommerce?

Yes, both have a dedicated publishing tool, as does PrestaShop. Shopify additionally has three specific tools: list the store's blogs, update the connection, and find the products, collections and articles relevant to a given topic. One difference worth knowing: on Shopify the default status publishes live, whereas on WordPress it creates a draft.

Can I update existing content?

Yes, that is the update-posts family, which carries the same ten verbs as articles. It is built to rework already-published content without changing its URL, which preserves the page's age and the links pointing at it. On a site that already has a stock of pages, that is often the best effort-to-result ratio.

What is the difference between Wisewand and Haloscan MCP?

They are two complementary MCP servers, not competitors. Haloscan covers research: keywords, volumes, analysis of search results and competitors. Wisewand covers production and publishing. Declared side by side in the same client, your LLM chains them without you having to coordinate anything: research, choose, write, publish.

Can I generate 100 articles in bulk?

Yes, bulk creation is built for it, and the bulk estimate exists precisely to price a series of 50 creations without running a single one. Two things to watch: rate limiting is 60 requests per minute on a global bucket, and credits are consumed at creation since creation already queues the generation. Price first, launch second.

Is the content unique and SEO-optimized?

Every piece is generated for your request, from your brief and your persona, and is not assembled from a template. The structure produced is the one a search engine expects: heading hierarchy, FAQ section, table of contents, metadata, internal links. No tool can promise a position in Google, and we do not promise one: what Wisewand gives you is properly structured content, produced at a cost that makes regularity possible.

Can I add my own research or sources to the articles?

Yes. The field provided for it accepts free-form context, and the subject field itself accepts source URLs. In a conversation, simply mention them. From a terminal, pass them in the payload file with --input. You can also edit the generated content afterwards with the output-update tool, bearing in mind that it expects HTML.

Get started

Collect your key on app.wisewand.ai/api, install the package, and make your first call. Three lines, and you have both doors at once: the server for your LLM, the command for your scripts.

npm install -g @wisewandtools/mcp-server
wisewand login
claude mcp add wisewand -- npx -y @wisewandtools/mcp-server

A question, a piece of feedback, a case that does not fit the boxes: [email protected].

API documentation

• For a human: api.wisewand.ai/docs
• For a machine, the OpenAPI specification: api.wisewand.ai/docs/json

Complete mcp.json configuration

The file below works as-is for Claude Desktop, Cursor, VS Code and Windsurf. Replace the keys, and remember that this file must never enter a repository.

{
  "mcpServers": {
    "wisewand": {
      "command": "npx",
      "args": ["-y", "@wisewandtools/mcp-server"],
      "env": {
        "WISEWAND_API_KEY": "sk_live_YOUR_KEY"
      }
    },
    "haloscan": {
      "command": "npx",
      "args": ["-y", "@occirank/haloscan-server@latest", "start"],
      "env": {
        "HALOSCAN_API_KEY": "YOUR_HALOSCAN_KEY"
      }
    }
  }
}