DEV Community: Jonathan Harrison

Agentic development in practice: Building a weather MCP server with Spring AI and Cursor

Jonathan Harrison — Tue, 31 Mar 2026 07:28:27 +0000

Introduction

At the beginning of 2026, the UK was experiencing an unusually wet start — something that seemed to dominate everyday conversation. That got me thinking:

Why shouldn’t AI agents be able to join in too?

So I set out to build a weather-powered Model Context Protocol (MCP) server using Spring AI, developed with Cursor agents.

Along the way, I got to explore agentic development, learn new tooling, and solve a few unexpected challenges.

What I built

I built an Accuweather-powered MCP server that enables AI agents to query:

Current weather
Hourly forecasts
Daily forecasts

The server is published on the official MCP Registry and can be integrated into tools like Claude.

This allows LLMs to access structured, real-time weather data via tools—rather than relying on potentially outdated or hallucinated responses.

How it works

The MCP server exposes weather functionality as tools that AI agents can call via the Model Context Protocol.

At a high level:

Spring AI handles MCP integration and tool definitions
The server communicates with the AccuWeather API
MCP tools are exposed using annotations
AI agents (e.g. Claude) invoke these tools via structured requests

This architecture allows the model to fetch live data when needed, making responses more accurate and reliable.

How I got up to speed

Cursor

Cursor provides excellent resources for getting started with agentic development that includes plenty of guidance, recommendations and best practises.

Model Context Protocol

If you’re new to MCP, the official documentation is a great starting point.

I’d also strongly recommend reading the specification itself — it covers important details like:

Error handling
Security considerations
Implementation patterns

Spring AI

The Spring AI reference documentation provides solid guidance on MCP and broader Generative AI concepts such as chat clients and RAG.

One of the most useful resources was the examples repository, which demonstrates how everything fits together—particularly how to use MCP annotations to define tools.

Gotchas

These were the issues that slowed me down the most and are likely to help others building something similar.

Cursor

My goal for this project was to lean into agentic development and minimise hand-written code.

Initially, I tried a one-shot approach: generating a full plan and letting the agent implement the feature. It worked—but produced far more code than I wanted, and used patterns I wouldn’t normally choose.

To improve this, I made a few changes:

Added guard rails: Unit and integration tests, code formatting with spotless, code analysis using checkstyle
Incremental rule creation: Whenever the agent made a mistake (e.g. using Maven instead of Gradle, or missing JSpecify nullability annotations), I added rules to AGENTS.md
Used Plan mode and auto model selection: This helped optimise usage and extend the limits of the Hobby plan.
Develop in increments: Instead of building full features in one go, I broke them into layers: HTTP client, Gateway and MCP tool. This made it easier to review and course-correct.
Referenced existing code: Once patterns were established, I used them as examples to guide the agent.

By the time I implemented the hourly forecast feature, I was able to generate a plan and delegate execution to a Cloud Agent—only needing to review the result.

Spring AI

A few things weren’t immediately obvious from the docs:

Turn off console logging: MCP servers using stdio must only output JSON-RPC messages. Any logging to stdout will break the integration with an MCP client.

logging:
  console:
    enabled: false

MCP Server annotations: To use MCP Server Annnotatons which simplifies the creation of MCP server functionality like tools, you need to include the org.springframework.ai:spring-ai-mcp-annotations dependency and import them from org.springaicommunity.mcp.annotation.*.
Debugging with MCP Inspector: If you want to use the MCP Inspector to debug your MCP server, use the following command:

npx @modelcontextprotocol/inspector -e 'JAVA_TOOL_OPTIONS=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005' java -jar "build/libs/accuweather-mcp-local-snapshot.jar"

Testing with Claude: If you want to test your MCP server using Claude, refer to the MCP docs. Since I use sdkman, the command value needed to be ~/.sdkman/candidates/java/current/bin/java.

Publishing to the MCP registry

Publishing to the Official MCP registry introduced a few additional challenges:

Docker multi-platform builds: semenatic-release docker plugins only support amd64. Since I was on an ARM-based Mac I needed arm64 support and because I was already using jib to containerize my application, I opted to use @semantic-release/exec and jib directly to publish to Docker Hub.
Validating server.json: The mcp-publisher CLI includes a validate command - use it early to verify your MCP server definition (server.json). I added this step to CI after encountering issues with description length during publishing.

Closing thoughts

This project was a great way to explore agentic development in practice — moving beyond simple prompts to structured, tool-driven systems. As well as getting familiar with the Model Context Protocol and Spring AI.

And if nothing else, at least your AI will finally be able to complain about the weather too.

Part 4: DigitalOcean App Platform Hackathon Submission

Jonathan Harrison — Sat, 26 Dec 2020 13:42:09 +0000

This post is part of a series detailing my journey with golang from learning the language to entering the DigitalOcean App Platform Hackathon.

The app I built can be found on GitHub.

Part 4 details the DigitalOcean App Platform Hackathon submission and how it is deployed.

What I built

Category Submission

Random Roulette

App Link

N/A

Screenshots

Description

stock-checker is a golang app that spawns a task every hour to check whether any of the following UK retailers have an Xbox Series X console in stock:

This is done using a web automation library that navigates each site in a headless chromium browser.

If the app determines stock is available, a text message is sent using Twilio to the configured mobile number.

This is deployed to a DigitalOcean App Platform Worker using a Dockerfile.

Link to Source Code

GitHub

Permissive License

MIT

Background

See Part 1 of this series.

How I built it

See Part 3 of this series.

Hosting and deployment

This golang app is deployed using docker to a Worker component on DigitalOcean's App Platform.

The DO App is defined using an Application Reference specification which is shown below:

name: stock-checker-app
region: fra
workers:
- name: bg-worker-stock-checker
  github:
    branch: main
    deploy_on_push: true
    repo: JonJam/stock-checker
  dockerfile_path: Dockerfile
  instance_count: 1
  instance_size_slug: basic-xs
  envs:
  - key: SC_TWILIO_ENABLED
    scope: RUN_AND_BUILD_TIME
    value: "true"
  - key: SC_TWILIO_ACCOUNTSID
    scope: RUN_AND_BUILD_TIME
    type: SECRET
    value: ""
  - key: SC_TWILIO_AUTHTOKEN
    scope: RUN_AND_BUILD_TIME
    type: SECRET
    value: ""
  - key: SC_TWILIO_NUMBERTO
    scope: RUN_AND_BUILD_TIME
    type: SECRET
    value: ""
  - key: SC_TWILIO_NUMBERFROM
    scope: RUN_AND_BUILD_TIME
    type: SECRET
    value: ""

This App was then deployed using doctl.

Originally I was going to use a Deploy to DigitalOcean button, however worker components are not currently supported.

Prior to this project, I wasn't familiar with Digital Ocean so using the App Platform was new to me. The resources I found useful are listed below:

Additional Resources / Info

Part 3: Developing stock-checker app

Jonathan Harrison — Sat, 26 Dec 2020 13:15:06 +0000

This post is part of a series detailing my journey with golang from learning the language to entering the DigitalOcean App Platform Hackathon.

The app I built can be found on GitHub.

Part 3 details:

golang packages used to build stock-checker
docker setup for both development and production
Integrating with Twilio SMS API

Overview

stock-checker is a golang app that spawns a task every hour to check whether any of the following UK retailers have an Xbox Series X console in stock:

This is done using a web automation library that navigates each site in a headless chromium browser.

If the app determines stock is available, a text message is sent using Twilio to the configured mobile number.

golang packages

A number of different packages were used to build this app which are detailed in this section.

These packages were discovered on Awesome Go.

Web Automation - go-rod/rod

rod is a high-level driver for the DevTools Protocol.

This package is used to navigate the various retailer's sites to find the Xbox Series X console listing. Once found, it checks whether the console is in or out of stock.

Notable features include:

Configuration - spf13/viper

Viper is a configuration package that supports reading configuration files in various formats, as well as from environment variables.

This is being used to control:

The scheduler interval
Debug settings for rod
Enables/disables sending notifications and the secrets used to communicate with Twilio.

I used an envfile to define the app's configuration. Originally, I tried using a YAML file but due to a couple of issues, I had to swap the file format.

To help others, here are the issues I ran into when using YAML:

GitHub Issue: If you want to override a YAML subobject property with an environment variable, you have to name the variable using the following format: PREFIX_SECURE.KEY. DigitalOcean App Platform environment variables do not support . in the name.
GitHub Issue: If you want to override a YAML subobject property with an environment variable and unmarshal that object to a struct, this isn't currently possible. This is because viper.UnmarshalKey doesn't take account of environment variables.

Scheduler - go-co-op/gocron

goCron is a scheduling package that lets you run functions periodically at a pre-determined interval.

This is being used to run a task once an hour that checks the various retailers and if applicable, sends a notification.

docker support

To simplify running the app on DigitalOcean, I added docker support which this section covers.

Dockerfile

This amazing JetBrains blog post series greatly inspired the Dockerfile created for this project.

Using multi-stage builds it provides both a development image with debugging support and a production image.

# Builder
FROM golang:1.15.6-buster AS builder
COPY . /src
WORKDIR /src
RUN go get github.com/go-delve/delve/cmd/dlv
RUN go build -gcflags="all=-N -l" -o app-dev
RUN go build -o app

# Base runner
FROM debian:10.7 AS base-runner
RUN apt-get update && apt-get install -y \
    ca-certificates \
    chromium \
    && rm -rf /var/lib/apt/lists/*

# Dev runner
FROM base-runner AS dev-runner
WORKDIR /server
COPY config.env /server
COPY --from=builder /src/app-dev /server/app
COPY --from=builder /go/bin/dlv /server
EXPOSE 40000
CMD ["/server/dlv", "--listen=:40000", "--headless=true", "--api-version=2", "--accept-multiclient", "exec", "/server/app"]

# Prod runner
FROM base-runner AS prod-runner
WORKDIR /server
COPY config.env /server
COPY --from=builder /src/app /server
CMD ["./app"]

docker-compose

To assist with development, this docker-compose file starts a development container with debugging enabled and enables a few rod debug options via environment variables.

version: "3.9"

services:
  app:
    build:
      context: ./..
      target: dev-runner 
    security_opt:
      - seccomp:unconfined
    cap_add:
      - SYS_PTRACE
    container_name: stock-checker-$USER

    ports:
      - "40000:40000" # DEBUG

    environment:
      - SC_ROD_TRACE=true
      - SC_ROD_PAGEPOOLSIZE=1

Remote debugging using VS Code

To remote debug the app within docker, we need to create a launch configuration by following this guide.

The resulting config looks like this:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch and debug in Docker",
            "type": "go",
            "request": "attach",
            "mode": "remote",
            "cwd": "${workspaceFolder}",
            "port": 40000,
            "host": "127.0.0.1",
            // This corresponds to the directory the app is built in
            "remotePath": "/src"
        },
    ]
}

Integrating with Twilio

Twilio is being used to send a SMS when the app detects a Xbox Series X console is in stock.

Originally, I was going to use saintpete/twilio-go which I discovered here. However I ran into issues with this package due to incompatible package versions.

In the end, I went with a simpler approach and ended up following this blog post to integrate with their SMS API directly.

That's it for this post.

In the final part, I will detail my DigitalOcean App Platform Hackathon submission as well as deploying to DigitalOcean.

Part 2: Development environment

Jonathan Harrison — Sat, 26 Dec 2020 12:37:11 +0000

The cover image is from MariaLetta/free-gophers-pack

This post is part of a series detailing my journey with golang from learning the language to entering the DigitalOcean App Platform Hackathon.

The app I built can be found on GitHub.

Part 2 details the setup of my golang development environment.

Setup `golang`

Install `golang`

First step is to install golang which can be done by following this page.

Create workspace

This step is not required when using modules. See the note on this page.

Create a workspace which results in the directory structure shown below.

$HOME
    └── go
        ├── bin
        └── src

Set environment variables

Next I added the following environment variables to my .zshrc file.

export GOPATH=/Users/jonjam/go
export GOBIN=/Users/jonjam/go/bin
export PATH=$GOPATH/bin:$GOROOT/bin:$PATH

More information about these variables can be found here.

Setup Visual Studio Code

There are plenty of choices when it comes to IDEs. I went with Visual Studio Code, since I was already familiar with it.

This section details configuring it for golang.

Install and activate Go extension

First to add golang support to VS Code, install the Go extension.

After installing the extension, there are some additional command line tools that also need to be installed to support the extension. This can be done by following this page.

Configure formatting tool

The default formatting tool in VS Code is goreturns which doesn't work with modules (see here for more information).

goimports on the other hand does support modules.

Change the go.formatTool setting to goimports.

Enable the Go language server

Besides formatting, some of the other helper tools do not support modules (see here for more information).

The Go language server should be used; this can be enabled by following these steps.

Setup debugging

Debugging golang apps in VS Code is provided by Delve.

Follow these steps to install and configure Delve.

Setup linter

Now that VS Code is setup, the final step is to choose a linter to assist with development.

I chose golangci-lint. It is a fast go linters runner that is capable of running multiple linters in parralel.

I discovered this on golang wiki.

Install

golangci-lint can be installed locally by following these steps.

Configure linting tool

To integrate golangci-lint with VS Code, it is just a matter of changing a couple of settings.

Create configuration file

The final step is to create a .golangci.yml for the project which defines what linters are enabled. This can also be used to enable/disable specific rules.

Below is the .golangci.yml file from stock-checker app:

linters:
  disable-all: true
  enable:
    # Default enabled linters
    - deadcode
    - errcheck
    - gosimple
    - govet
    - ineffassign
    - staticcheck
    - structcheck
    - typecheck
    - varcheck

    # Added
    # goimports aligns with VS Code setup and includes gofmt
    - goimports
    - golint

That's it for this post.

In part 3, I will talk about developing the project.

Part 1: Background and learning golang

Jonathan Harrison — Sat, 26 Dec 2020 11:50:13 +0000

The cover image is from MariaLetta/free-gophers-pack

This post is part of a series detailing my journey with golang from learning the language to entering the DigitalOcean App Platform Hackathon.

The app I built can be found on GitHub.

Part 1 details:

How I came up with the project idea
How I learnt golang

Background

In August 2020, I wanted to start a new side project and learn something new.

At the top of my backlog was golang.

In the following months, I completed online courses and read blogs, guides, language specification etc to get familiar with the language.

At the beginning of December, I thought it was about time I built something.

At the same time, my youngest brother who had missed getting a Xbox Series X on the UK launch day decided that he wanted one. What transpired was every time a UK retailer potentially had a re-stock, my two brothers and I would be checking their website throughout the day to try buy one; only to fail every time.

Then I saw this DEV post. This inspired me to build an app in golang that would check various UK retailers for a Xbox Series X and notify my brothers and I when available.

Lastly I saw that DigitalOcean were hosting a Hackathon. This provided an opportunity to also get experience working with a cloud platform I hadn't used before and more importantly, gave me a deadline to work to.

This series details the journey of building the stock-checker app:

Part 1 - Learning golang (this one)

Part 2 - Development environment

Part 3 - Developing the stock-checker app

Part 4 - Deploying to DigitalOcean

Learning golang

How I tend to learn something new is by trying to expose myself to as much information as possible from a variety of sources, even if I can't remember it all.

This is so that when I start building something I do it the right way and also, it gives me mental "hints" to further lookup things during development.

With that, here are the resources I used to learn golang.

Online courses

Documentation

golang.org

Particular areas of golang.org:

Go Blog

The Go Blog has many posts going into depth about aspects of the language.

golang/go GitHub

The GitHub Wiki contains many resources for every aspect of programming with golang from learning, tools and libraries.

go.dev

go.dev details the different use cases of golang such as cloud and network services as well as companies using it for that purpose and libraries/frameworks to consider.

That's it for this post.

In part 2, I will talk about my development environment.

DEV Community: Jonathan Harrison

Agentic development in practice: Building a weather MCP server with Spring AI and Cursor

Introduction

What I built

How it works

How I got up to speed

Cursor

Model Context Protocol

Spring AI

Gotchas

Cursor

Spring AI

Publishing to the MCP registry

Closing thoughts

Part 4: DigitalOcean App Platform Hackathon Submission

What I built

Category Submission

App Link

Screenshots

Description

Link to Source Code

Permissive License

Background

How I built it

Hosting and deployment

Additional Resources / Info

Part 3: Developing stock-checker app

Overview

golang packages

Web Automation - go-rod/rod

Configuration - spf13/viper

Scheduler - go-co-op/gocron

docker support

Dockerfile

docker-compose

Remote debugging using VS Code

Integrating with Twilio

Next

Part 2: Development environment

Setup golang

Install golang

Create workspace

Set environment variables

Setup Visual Studio Code

Install and activate Go extension

Configure formatting tool

Enable the Go language server

Setup debugging

Setup linter

Install

Configure linting tool

Create configuration file

Next

Part 1: Background and learning golang

Background

Learning golang

Online courses

Documentation

golang.org

Go Blog

golang/go GitHub

go.dev

Next

Setup `golang`

Install `golang`