Vyriy

MCP server in one command with Vyriy

AI tools are becoming more useful when they can do more than just answer questions.

A model can explain code, generate text, or help with architecture. But when it needs to interact with a real system — read project data, call internal APIs, search documentation, run safe actions — it needs a bridge.

That bridge is often MCP.

MCP, or Model Context Protocol, is a simple way to expose tools and context to AI applications. Instead of hardcoding integrations for every client, we can build a small MCP server and let compatible tools connect to it.

Vyriy now includes an MCP preset that helps generate a ready-to-run MCP server.

You can create it with one command:

npm create vyriy@latest

The example is available here:

https://vyriy.dev/examples/vyriy-preset-mcp/

What the preset gives you

The generated project gives you a minimal MCP server with one example tool:

hello_world

This is intentionally small.

The goal is not to hide MCP behind a large framework. The goal is to give you a clean starting point:

  • a working server
  • a predictable project structure
  • one simple tool
  • a place where you can add your own tools
  • a setup that is easy to run and test locally

For Vyriy, this is important. A good preset should not feel magical. It should give you enough structure to start, but still let you understand what is happening.

Why start with hello_world

The first tool does not need to be complex.

A simple hello_world tool proves that the server works, the MCP endpoint is reachable, and the client can call the tool correctly.

After that, you can replace the example with something real:

  • search project documentation
  • expose internal API actions
  • read generated metadata
  • return deployment information
  • provide reusable project commands
  • connect an AI assistant to your own developer tooling

This is where MCP becomes useful. The model does not need direct access to everything. It only gets the tools you explicitly expose.

Tools can return more than text

Usually, the first response from a tool is just text. For example, a tool can return a small message that confirms that the server is alive.

But MCP tools are not limited to plain text.

According to the MCP tools specification, a tool result can contain different content types.

The simplest one is text:

{
  "type": "text",
  "text": "Tool result text"
}

Text is useful for explanations, summaries, logs, validation messages, or generated instructions.

A tool can also return image content:

{
  "type": "image",
  "data": "base64-encoded-data",
  "mimeType": "image/png"
}

This can be useful when a tool generates a chart, diagram, screenshot, preview, or visual report.

Audio content is also supported:

{
  "type": "audio",
  "data": "base64-encoded-audio-data",
  "mimeType": "audio/wav"
}

For developer tools, one of the most interesting types is a resource link:

{
  "type": "resource_link",
  "uri": "file:///project/src/main.ts",
  "name": "main.ts",
  "description": "Primary application entry point",
  "mimeType": "text/typescript"
}

A tool can use this when it wants to point the client to a file, document, generated artifact, or another resource without embedding the full content directly in the response.

MCP also supports embedded resources:

{
  "type": "resource",
  "resource": {
    "uri": "file:///project/src/main.ts",
    "mimeType": "text/typescript",
    "text": "console.log('Hello from Vyriy MCP')"
  }
}

This is useful when the tool wants to return the actual content of a resource as part of the result.

For more structured integrations, a tool can also return structuredContent. This allows the server to return a JSON object that can be validated with an outputSchema.

For example, a future Vyriy MCP tool could return project metadata like this:

{
  "content": [
    {
      "type": "text",
      "text": "{\"name\":\"vyriy-app\",\"preset\":\"mcp\",\"tools\":[\"hello_world\"]}"
    }
  ],
  "structuredContent": {
    "name": "vyriy-app",
    "preset": "mcp",
    "tools": ["hello_world"]
  }
}

This is important because AI tools often need both human-readable output and machine-readable data.

A text response is easy for a person to read.

A structured response is easier for a client, agent, or workflow to validate and reuse.

That means a Vyriy MCP server can grow naturally from one simple hello_world tool into something more useful:

hello_world
search_docs
get_project_info
list_presets
read_package
generate_config

Each tool can decide what kind of result makes sense.

Some tools return text.

Some return structured JSON.

Some return links to resources.

Some may eventually return generated previews, screenshots, or reports.

The important part is the same: every capability is explicit, typed, and visible at the boundary between the AI client and the system.

Testing with LM Studio

One simple way to check the generated MCP server is LM Studio.

After starting the server, you can connect it using an mcp.json configuration like this:

{
  "mcpServers": {
    "vyriy": {
      "url": "http://localhost:3000/mcp"
    }
  }
}

After LM Studio loads this configuration, the vyriy MCP server becomes available to the model, and the generated hello_world tool can be called from the AI client.

This makes the local feedback loop very short:

  1. generate the project
  2. run the server
  3. connect it in LM Studio
  4. call the tool
  5. replace hello_world with your own logic

Why this belongs in Vyriy

Vyriy is not trying to be another heavy framework.

It is a collection of calm, explicit building blocks for projects that need to be understandable, deployable, and easy to extend.

MCP fits this idea well.

An MCP server is just another boundary. It exposes a controlled interface between an AI client and your system. That boundary should be small, readable, and safe to reason about.

With the MCP preset, Vyriy gives you a starting point for building that boundary.

Not as a black box.

Not as a giant agent framework.

Just a small server with a clear tool contract.

What can be built next

The generated MCP server starts with hello_world, but the useful part is what comes after.

For example, a Vyriy MCP server could later expose tools like:

search_docs
create_project
list_presets
explain_package
generate_config

That means an AI assistant could help a developer understand a project, search internal documentation, or generate parts of a system using the same calm building blocks that Vyriy already provides.

The important part is that every tool is explicit.

The AI does not own the system. It receives a clear list of allowed actions.

That is a healthier model for real projects.

Conclusion

MCP is a small but powerful idea: give AI tools a controlled way to interact with real systems.

The Vyriy MCP preset makes it easy to start experimenting with that idea:

npm create vyriy@latest

You get a working MCP server, one example hello_world tool, and a simple path to testing it with LM Studio.

From there, you can build your own tools step by step.

At first, a tool can return a simple text response.

Later, it can return structured data, resource links, embedded resources, images, or other content types supported by MCP.

That makes the MCP server more than a small demo. It becomes a clean integration boundary between an AI client and your real project.

Calmly.

Explicitly.

One boundary at a time.