Jihye's Blog

Photo by Growtika on Unsplash

Recently I started experimenting with MCP (Model Context Protocol) servers while working on production code. I maintain an internal server that communicates with Shopify, and integrating an MCP server into my workflow has significantly improved how I develop, debug, and understand Shopify APIs.

The Problem: Working With APIs You Don’t Fully Know

In my case, I was maintaining an internal server that interacts with Shopify. The system includes legacy code and some outdated integrations. When I first started working on it, I had:

• almost zero knowledge of Shopify APIs
• rusty GraphQL knowledge
• limited context about how Shopify structures their API schemas

Normally, this would mean spending hours jumping between documentation, testing queries manually, and piecing together examples from different sources.

That’s where MCP came in.

Using a Shopify MCP Server

I enabled a Shopify MCP server and connected it to an AI coding agent (I use Cursor). This setup allows the AI to directly interact with structured Shopify resources instead of relying only on its training data.

With MCP enabled, the AI agent can:

• search Shopify documentation
• explore API schemas
• generate GraphQL queries
• validate code against real API rules
• provide up-to-date answers about Shopify APIs

Some of the tools provided by the Shopify MCP server include:

• learn_shopify_api
• search_docs_chunks
• validate_graphql_codeblocks

These tools allow the AI agent to retrieve accurate information and validate responses before presenting them to me.

My Workflow With Cursor + MCP

My workflow is very simple:

1. I write a prompt in Cursor.

2. The AI agent queries the Shopify MCP server.

3. It returns accurate documentation references, working GraphQL queries, and explanations aligned with Shopify best practices.

Instead of generic answers, the AI can inspect schemas, verify queries, and produce much more reliable solutions.

Using Cursor Rules to Improve Results

Another trick that improved my workflow is using Cursor rules. By defining rules for how the AI should behave when interacting with the MCP server, I can encourage it to:

• prefer MCP tools over guessing
• validate GraphQL queries before returning them
• search documentation when uncertain

This small setup noticeably improves the quality of responses and reduces debugging time.

Real Impact on My Work

Even though MCP is still relatively new to me, the impact was immediate.

It helped me:

• understand Shopify APIs much faster
• generate correct GraphQL queries
• identify missing parts in our legacy code
• improve the flow for updating Shopify orders

What would normally take days of research became much faster. For someone starting with zero Shopify API knowledge, MCP dramatically reduced the learning curve.

Learning MCP

If you're new to MCP like I was, I recommend Brian Holt’s course. It's beginner-friendly and very thorough, and helped me understand how MCP works and how to start applying it in real workflows.

What I’m Exploring Next

One thing I’m currently experimenting with is building a script to manage multiple MCP servers. Instead of manually enabling servers, I’d like to run multiple MCP servers or selectively enable them depending on the task. This could turn the AI agent into something closer to a multi-tool engineering assistant.

Another benefit of this approach is team alignment. If engineers working on the same repository share the same MCP configuration or scripts, everyone can use the same tools, documentation sources, and API context. This helps ensure that AI-assisted workflows are consistent across the team and reduces confusion or duplicated effort.

In other words, MCP servers could become part of the shared developer tooling for a project, similar to linters, formatters, or CI scripts.

Changing My Perspective on AI

Like many engineers, I’ve sometimes felt overwhelmed by how quickly AI is evolving.

But working with MCP changed my perspective.

Instead of worrying about AI replacing engineering work, I see how it can augment what we do:

• improving code quality
• increasing development speed
• reducing time spent searching documentation

The important skills now are learning:

• how to use AI correctly
• how to use it effectively
• how to build tools and systems with it

Those skills can dramatically improve productivity.

Final Thoughts

MCP servers are still new, but even early use has already improved my workflow.

For API-heavy work like Shopify integrations, giving an AI agent the ability to explore schemas, search documentation, and validate queries is incredibly powerful.

If you work with complex APIs or large documentation sets, it’s definitely worth experimenting with MCP.