From Zero to Agentic Query in One Afternoon: Build a GraphQL API and Expose It to an LLM Agent via MCP
GraphQL, LLM, Java, Spring, API
Key Takeaways
- Working example of the pattern everyone is asking about right now: exposing your existing data to AI (APIs for AIs).
- A solid working grasp of GraphQL fundamentals: schema design, resolvers, relationships, and the N+1 problem with DataLoaders.
- Patterns to make GraphQL APIs safe to expose, using field-level authorisation and input validation.
- A clear, practical understanding of what MCP is and why it matters for connecting APIs to AI agents.
- The concrete pattern for exposing a GraphQL API as an MCP server so that an LLM agent can use it without hand-written integration code.
- How to add basic agent guardrails: operation scoping and query limits.
- The judgment to know when an agent-facing GraphQL API is the right architectural choice and when it isn't.
Target Audience
- Java developers looking for a practical introduction to GraphQL and AI agent integration.
- Backend and full-stack engineers interested in exposing existing services to LLMs.
- Tech leads and architects evaluating GraphQL or agent-based integrations.
- Developers with no prior GraphQL experience who want a hands-on, real-world example.
Requirements
- A laptop with JDK 21 or later installed.
- An IDE of choice (the workshop will use IntelliJ IDEA, but any Java IDE is suitable).
- Git and Maven installed and configured.
- An LLM client such as Claude Desktop.
- Comfortable building and running basic Spring Boot applications.
- Familiarity with Java, Maven, and Git workflows.
- No prior GraphQL, AI, LLM, or MCP experience required.
Duration
4 hours (including a break)
Schedule
Workshop Plan
Introduction and GraphQL Fundamentals (30 min)
- Why GraphQL and when to choose it over traditional APIs.
- Core GraphQL concepts and terminology.
- Designing the schema for the sample application.
Building a GraphQL API with Spring for GraphQL (80 min)
- Creating schemas and resolvers using schema-driven development.
- Modelling relationships between entities.
- Solving the N+1 problem using DataLoaders.
- Adding field-level authorisation and input validation.
Break (10 min)
Introduction to MCP and Agent Tooling (30 min)
- Understanding the Model Context Protocol (MCP).
- How AI agents discover and invoke tools.
- MCP compared to traditional function calling approaches.
Exposing a GraphQL API Through MCP (80 min)
- Wrapping the GraphQL API as an MCP server.
- Connecting a live LLM client to the API.
- Observing how agents introspect and query GraphQL schemas.
- Implementing guardrails such as operation scoping and query limits.
- Building a complete end-to-end AI-accessible API.
Wrap-up and Q&A (10 min)
- When this architecture is the right choice.
- Common pitfalls and limitations.
- Next steps and further learning resources.