The Challenge: Three Ways to Build, One Smooth Experience

When you’re trying to revolutionize Minecraft building at ACDC 2026, you don’t just slap together some forms and call it a day. You create a Build Studio – a glossy, performant, multi-modal interface that lets users build however they want: with AI, with forms, or with actual physical blocks and a webcam.

And you do it all client-side, because nobody has time for round-trip server rendering in 2026.

The Solution: Glassmorphism Meets Real-Time Performance

Our Build Studio is a Power Pages-based interface that showcases three distinct building experiences:

1. AI Build Assistant 🤖

An embedded Copilot Studio chatbot that understands natural language building requests. Users describe what they want (“a stone house at spawn”), and the AI translates it into Minecraft structures.

2. Manual Builder 🛠️

A form-based interface with real-time validation and smooth transitions. Pick your structure type, set coordinates, choose materials – all with instant visual feedback and zero page reloads.

3. Physical Building Station 📷

The crown jewel: a live webcam feed showing a physical grid where users place Minecraft block miniatures. Motion detection via micro:bit triggers snapshots that get analyzed and replicated in-game.

The Client-Side Salsa: How We Dance

Let’s talk about what makes this solution tick from a client-side performance perspective:

🎭 CSS-Powered Animations (Zero JavaScript Overhead)

css
@keyframes float {
    0%, 100% { transform: translateY(0px); }
    50% { transform: translateY(-10px); }
}

.glossy-card {
    transition: all 0.4s cubic-bezier(0.4, 0, 0.2, 1);
    backdrop-filter: blur(20px);
}

.glossy-card:hover {
    transform: translateY(-8px);
    box-shadow: 0 30px 80px rgba(0, 0, 0, 0.2);
}

Every hover effect, every transition, every card elevation – handled by hardware-accelerated CSS transforms. No jQuery, no heavy animation libraries, just pure CSS3 goodness that runs at 60fps on any device.

🖼️ Glassmorphism UI with Layered Gradients

css
.glossy-card {
    background: linear-gradient(180deg, 
        rgba(240, 242, 247, 0.98) 0%, 
        rgba(230, 232, 237, 0.95) 100%);
    backdrop-filter: blur(20px);
    border: 1px solid rgba(200, 205, 210, 0.5);
    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.15);
}

Modern glassmorphism design that creates depth without images. The backdrop-filter alone gives us that premium iOS/Fluent Design feel, and layered gradients with rgba transparency keep it buttery smooth.

⚡ Real-Time Webcam Updates (Efficient Polling)

javascript
setInterval(() => {
    const webcam = document.getElementById('liveWebcam');
    if (webcam) {
        webcam.src = 'http://localhost:8080/snapshot?t=' + Date.now();
    }
}, 1000);

Live camera feed that updates every second without reloading the entire page. The cache-busting timestamp ensures we always get the latest frame, and the conditional check prevents errors if the element isn’t visible.

🎯 Form Validation Without Page Reloads

javascript
document.getElementById('manualBuildForm').addEventListener('submit', function(e) {
    e.preventDefault();
    document.getElementById('buildStatus').style.display = 'block';
    
    // Client-side validation and API call
    // No page refresh, just smooth state updates
});

Classic progressive enhancement: the form works without JavaScript, but with it enabled, we get instant feedback, loading states, and success messages – all without ever leaving the page.

🎨 Dynamic Section Dividers (Because Aesthetics Matter)

html
<div style="height: 2px; 
     background: linear-gradient(90deg, transparent, #667eea, transparent); 
     margin: 3rem 0;">
</div>

Instead of boring `<hr>` tags, we use gradient-based dividers that add visual polish without any image assets. Pure CSS art.

🧩 Component-Based Structure (Maintainability FTW)

Each building mode is encapsulated in its own section with:

• Isolated CSS classes (`.glossy-header-ai`, `.glossy-header-manual`)
• Dedicated form handlers
• Independent state management

This means we can modify the AI builder without touching the webcam feed, or update the manual builder without breaking the physical station.

Performance Metrics That Matter

Let’s talk numbers:

• Zero Image Assets for UI Elements – Every button, card, and gradient is pure CSS. No image downloads = faster initial load.
• Sub-100ms Interaction Response – CSS transitions at `0.3s` feel instant. Form validation happens in microseconds.
• 1-Second Webcam Refresh – Real-time enough to feel live, infrequent enough to not hammer the server.
• Lazy-Loaded Copilot Studio – The chatbot iframe only loads when the AI Builder section is active, saving bandwidth for users who just want the manual builder.

The “Salsa” in Client Side Salsa

🕺 Responsive Design Without Media Query HellWhat makes this solution dance?

css
.structure-btn {
    padding: 1.25rem 0.75rem;
    border-radius: 16px;
    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
}

Flexible padding, relative units, and modern layout techniques (flexbox/grid implied in the structure) mean the interface adapts beautifully from phone to ultrawide monitor.

💃 State Management Without Frameworks

We don’t need React or Vue for this. Clean vanilla JavaScript with event listeners and direct DOM manipulation is fast, debuggable, and has zero build overhead.

🎶 Smooth Transitions Everywhere

Every button press, every form submission, every section change – they all glide smoothly with cubic-bezier easing. It feels premium because it is premium.

The Tech Stack (What We’re NOT Using)

Sometimes what you leave out matters as much as what you put in:

❌ No jQuery (it’s 2026, come on)
❌ No React/Vue/Angular (overkill for this use case)
❌ No heavy animation libraries
❌ No Bootstrap bloat
❌ No unnecessary polyfills

Just modern, standards-based HTML5, CSS3, and ES6+ JavaScript that runs natively in every browser.

Real-World User Experience

Here’s what happens when a user lands on Build Studio:

1. Instant Load: No spinner, no skeleton screens. The UI is just… there.
2. Smooth Exploration: Hover over cards, see them float up with silky transitions.
3. Immediate Feedback: Click “Start Building” and get instant visual confirmation.
4. Live Updates: Watch the physical building station in real-time without refreshing.
5. Zero Friction: No loading bars, no “please wait”, no jank.

Why This Deserves the Badge

Client Side Salsa is about “well structured, modern client-side solutions with attention to performance, maintainability, and a great user experience.”

We’ve got:

✅ Modern: Glassmorphism, CSS animations, ES6+ JavaScript
✅ Performant: Zero unnecessary dependencies, hardware-accelerated rendering
✅ Maintainable: Component-based structure, clear separation of concerns
✅ Great UX: Smooth transitions, instant feedback, responsive design

Plus, we managed to create three distinct building experiences that all share the same design language and performance characteristics. That’s not just client-side work – that’s client-side choreography.

The Code That Makes It Sing

Want to see the magic? Check out our glossy button hover effect:

css
.structure-btn::before {
    content: '';
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background: linear-gradient(135deg, 
        rgba(17, 153, 142, 0.1) 0%, 
        rgba(56, 239, 125, 0.1) 100%);
    opacity: 0;
    transition: opacity 0.3s;
}

.structure-btn:hover::before {
    opacity: 1;
}

A pseudo-element overlay that fades in on hover. Simple, effective, performant. That’s the salsa.

Lessons Learned

1. CSS is powerful: Modern CSS can do things that used to require JavaScript libraries.
2. Less is more: Removing dependencies made our app faster, not slower.
3. Performance is a feature: Users notice smooth interactions, even if they don’t know why.
4. Design systems scale: Creating reusable `.glossy-*` classes made adding new features trivial.

Try It Yourself

Visit our Build Studio at the ACDC 2026 Minecraft House Builder site and experience the smoothness for yourself. Open your browser’s dev tools and watch the network tab – you’ll see how little we’re loading and how fast everything responds.

That’s Client Side Salsa. 💃🕺

We want a way for anyone who builds to claim ownership of their buildings, and a way for them to reference their building.

That is why we wanted to take advantage of Link Mobility’s SMS API. But we also wanted to do it as a low-code solution.

That is why we wanted to create a custom connector towards the API:

Configuring the connector

We chose the basic authentication method of the API. But we didn’t want to enter the platform partner ID every time we added the action. So we used paconn to edit the apiProperties.json file to add that as an extra parameter when creating the connection.
Like this:

apiProperties.json

Here we’re creating a custom Policy Template that adds the platformPartnerId parameter to the JSON in the body of the call.

Here is the flow that sends the SMS. It triggers when a row in our Minecraft Building table is added with a Owning Minecraft User or the Owning Minecraft User is updated with a value.

It then gets the Owning Minecraft User(It is just a relationship to the contact table) and checks if we have their mobile number and sends the SMS if we have it. The SMS contains the name of the Minecraft user as well as the name column of the Minecraft Building table which should be a unique name.

The action (in action):

PS! We don’t want anyone to answer the SMS so we’re using a shortcode as the sending number.

We’re more connected than ever, yet we crave authentic, tangible experiences. That’s why we integrated the micro:bit—not because we needed to, but because pressing physical buttons to spawn diamond towers feels right. It’s the same reason people still prefer vinyl records and pour-over coffee. Digital is great, but haptic feedback? That’s human.

“In a world of cloud-native abstractions, sometimes you just need to press a button and watch blocks materialize. It’s primal. It’s pure.”

Layer 1: The AI Whisperer

Our Copilot Studio integration isn’t just a chatbot—it’s a creative collaborator. Tell it “build me a castle at spawn” and it doesn’t just execute commands; it understands intention. It’s like having a barista who knows you want oat milk before you even ask.

The natural language processing happens in real-time, parsing your hipster jargon (“make it more industrial chic” = cobblestone and iron blocks) into executable build commands. It’s powered by Azure, because we believe in sustainable, scalable infrastructure—the craft brewery model, but for cloud computing.

Layer 2: The Webcam Oracle

Computer vision isn’t new. But using it to let you literally point at where you want structures? That’s bringing the physical back into the digital. We’re using Azure Custom Vision to detect block placement captured through your webcam. Put your block on the coordinates, and watch the magic happen.

It’s the digital equivalent of a Japanese tea ceremony—precise, intentional, mindful.

// The poetry of position { "type": "castle", "coordinates": { "x": handGesture.x * worldScale, "y": 64, // Always respecting the bedrock foundation "z": handGesture.z * worldScale }, "vibe": "minimalist-nordic" }

Layer 3: The Micro:bit Manifesto

Here’s where we get controversial: digital interfaces are overrated. Sometimes you need buttons. Real, clicky, satisfying buttons.

Our micro:bit integration lets you trigger builds with physical button presses. Button A “Build me a house”. Button B “Add a Tower”. Or prompt it to the AI. Random structure at random coordinates. It’s chaos theory meets brutalist architecture.

The Stack: Bleeding Edge, Obviously

Here’s where we separate ourselves from the herd. We’re not using last year’s tech. We’re using technology that’s so new, most developers haven’t even heard of it yet:

// The Stack Nobody Else Is Using (Yet) { "protocol": "MCP Protocol", // ← So new it still has that fresh-code smell "ai": { "vision": "GPT-4o Vision (latest)", // ← Because last month's model is vintage "language": "Mistral-Small 2503" // ← European AI, naturally }, "hardware": "micro:bit → Azure Cloud", // ← Physical meets ephemeral "vibe": "early-adopter-energy" }

MCP Protocol: The New Kid on the Block(chain)

MCP Protocol is so new that your senior architect probably hasn’t added it to the approved tech list yet. Model Context Protocol—it’s not just a communication layer, it’s a philosophy. We’re talking Day 1 adoption here. We’re not followers; we’re pathfinders.

While everyone else is still using REST APIs like it’s 2015, we’re pioneering standardized AI-to-tool communication. It’s the difference between buying avocados at Whole Foods and growing them in your rooftop garden.

GPT-4o Vision: Because 4 Is So Last Season

We’re running GPT-4o Vision—the latest release. Not GPT-4. Not GPT-4 Turbo. The “o” stands for “omni,” but we like to think it stands for “obviously better.” Computer vision that can understand context, intention, and aesthetic? That’s not AI; that’s an art critic.

Point your webcam at a spot in your Minecraft world, and GPT-4o Vision doesn’t just see coordinates—it understands composition. It knows that castle should be on the hill, not in the valley. It gets it.

Mistral-Small 2503: European Excellence

Plot twist: we’re also running Mistral-Small 2503. Why? Because supporting European AI innovation is the tech equivalent of shopping at local farmers’ markets. It’s fast, it’s efficient, and has something special that American models just can’t replicate.

micro:bit → Cloud: The Analog-Digital Bridge

Here’s the kicker: physical sensors streaming to cloud infrastructure. Your micro:bit accelerometer data travels through Azure IoT Hub in real-time, triggering builds based on literal hand movements. Shake your micro:bit? Build something. Tilt it? Change materials. It’s kinetic computing, and yes, we invented that term just now.

• MCP Protocol: Because standardization is the new disruption
• GPT-4o Vision: Multimodal AI before it was cool (it just became cool)
• Mistral-Small 2503: European AI sophistication
• micro:bit sensors: Haptic feedback in a post-haptic world
• Azure IoT Hub: Enterprise-grade infrastructure for artisanal builds

The Experience: Beyond the Screen

What we’ve created isn’t just a Minecraft builder. It’s a meditation on how we interact with digital spaces. Voice, vision, touch—we’re engaging multiple senses, creating what the French call je ne sais quoi in the world of DevOps.

When you describe a structure to our AI, watch it appear through your webcam, or press a physical button and see blocks materialize—you’re not just building. You’re creating. You’re part of something bigger than code, bigger than APIs, bigger than Azure regions.

In a world obsessed with “best practices” and “proven technologies,” we chose the path less documented. MCP Protocol? Barely any tutorials exist. GPT-4o Vision? Just released. Mistral-Small 2503? Most American developers don’t even know it exists.

Is it over-engineered? Absolutely. Is it necessary? Probably not. Is it the most hipster thing at ACDC 2026? Without question.

Why Responsive Matters for Us

Our Hybrid Builder system lets you build in Minecraft three ways:

1. Physical cardboard blocks on a camera-monitored plate
2. Voice commands through our AI contact center
3. Web ordering via Power Pages

The web interface needs to work everywhere – because you might be:

• Planning builds at your desktop
• Triggering structures from your phone while at the physical plate
• Reviewing orders on a tablet while moving between stations

The Nordic Aesthetic

We’ve gone full Scandinavian minimalist:

• Light backgrounds with generous space
• Informative icons (because who reads walls of text?)
• Clean pathways to deeper functionality
• Glossy polish that doesn’t break at 370px

The interface breathes. Icons stay crisp. Navigation remains intuitive whether you’re on a 4K monitor or checking your phone mid-build.

What’s Next

Adding real-time build status, integration with our webcam diff system, and making sure everything still looks gorgeous when people are hammering it with simultaneous orders!

Automated Hackathon Email Notifications with Power Pages, Dataverse & Power Automate

Hackathons move fast. Agendas change, sessions start on time (or at least try to), and participants don’t always remember when things are happening. To solve this, I built a fully automated notification flow using Power Pages, Dataverse, SharePoint, and Power Automate.

The goal?

Automatically email registered external users when a hackathon activity is about to start without manual work.

Architecture

[ Power Pages ]
      |
      v
[ Dataverse ]
(Registered users & emails)
      |
      v
[ Power Automate ]
(Scheduled every minute)
      |
      v
[ SharePoint List ]
(Hackathon agenda)
      |
      v
[ Email Notification ]

[ Power Pages ]
      |
      v
[ Dataverse ]
(Registered users & emails)
      |
      v
[ Power Automate ]
(Scheduled every minute)
      |
      v
[ SharePoint List ]
(Hackathon agenda)
      |
      v
[ Email Notification ]

---

Step 1: User Registration with Power Pages & Dataverse

External users register for the hackathon through a Power Pages site.

• The registration form collects email addresses
• All users are stored in a Dataverse table
• This table acts as the single source of truth for who should receive notifications

This makes it secure, scalable, and easy to reuse the user data later.

Step 2: Hackathon Agenda Stored in SharePoint

The hackathon agenda is maintained in a SharePoint list.

Each item in the list represents one activity and contains:

• Activity name
• Date
• Time
• A “processed” indicator (implemented using the Title field)

Why SharePoint?

• Easy to edit
• Non-technical users can maintain the agenda
• Perfect for structured, time-based data

Step 3: Scheduled Power Automate Flow (Every Minute)

A scheduled Power Automate flow runs every minute to keep everything in sync.

What it does:

1. Reads all agenda items from the SharePoint list
2. Checks if:
   • The current time is greater than or equal to the activity time
   • The activity has not been processed yet
3. If both conditions are true → action time

---

Step 4: Smart “Processed” Logic (No Duplicate Emails)

To prevent duplicate notifications:

• The flow appends “processed” to the Title field after sending emails
• Future runs of the flow ignore already processed items

Simple, effective, and transparent no extra columns required.

---

Step 5: Email Notifications to Registered Users

When an activity is due:

• The flow retrieves all email addresses from the Dataverse table
• Sends an email notification to all registered users
• Emails are only sent once per activity

---

Final Thoughts

This solution is a great example of how low-code tools can be combined to solve real-world event challenges in a clean and scalable way. It’s flexible enough to reuse for webinars, conferences, or internal events just swap the agenda and registration page.

Power Pages

email reminder

Dataverse list of users that started using the Agenda service elaborated in order to help all the people in the hackaton.

PixelPoint and TINT teams are using the solution, please refer to the image above, it is the email address of the people register in Dataverse.

DO NOT PRESS

Sometimes innovation isn’t about solving problems.
Sometimes it’s about proving that you can build something… even when you absolutely shouldn’t.

For the Community Champion challenge, I built a Canvas App with a single button:

After you click the button DO NOT PRESS, the system saves a line into a SharePoint list:

It has no business value, no purpose, and is wildly overengineered.
Naturally, it triggers multiple cloud services.

The Concept

The app presents the user with one very clear instruction: do not press the button.

If the user ignores this warning, the system reacts dramatically by:

1. Logging the incident in SharePoint
2. Triggering a Power Automate flow that triggers when a new item is created or modified.
3. Starting an Azure Automation Runbook that give an output like this:
   DO NOT PRESS was pressed by at 1/23/2026 2:31:53 PM. The time is 14:32:41
4. Sending a judgmental email to the person who pushed the button saying:
   “Why would you do that?”

Nothing is prevented. Nothing is fixed.
Everything is logged.

---

Architecture Overview

Canvas App
→ Power Automate (Instant Flow)
→ SharePoint List
→ Azure Automation Runbook
→ Email Notification

This design intentionally uses far more components than necessary to accomplish absolutely nothing.

---

Canvas App

The Canvas App contains:

• One screen
• One large, highly visible button
• Text: DO NOT PRESS

Button behavior

When pressed, the button:

• Window saying I TOLD YOU NOT TO PUSH THE BUTTON
• Created an item in SharePoint list
• Calls a Power Automate Cloud flow
• Passes the current user and timestamp
• Displays a notification confirming poor decision-making

There is no confirmation dialog.
There is no undo.

---

SharePoint List – Logging the Incident

A SharePoint list is used to permanently record the mistake.

List name: DoNotPressthebutton

Columns:

• Title – “They pressed the button at date and hour”

This ensures full auditability of an action that should never have happened.

---

Power Automate

The Power Automate flow is triggered directly from the SharePoint.

Flow steps:

1. Create SharePoint item
   Logs the button press immediately.
2. Start Azure Automation Runbook
   Passes user and timestamp as parameters.
3. Send Email (Outlook)
   Sends a message with the subject: Why would you do that?

The email confirms:

• Who pressed the button
• When it happened
• That the action has been recorded for no reason whatsoever

---

Azure Automation Runbook

The Azure Runbook exists solely to prove that this button press was serious enough to involve Azure.

The runbook:

• Receives parameters from Power Automate
• Writes a log entry such as: “DO NOT PRESS was pressed by at 1/23/2026 2:31:53 PM. The time is 14:32:41”

No resources are modified.
No remediation is performed.
The runbook completes successfully, as disappointed as possible.

---

Email Notification

An email is sent after the flow runs:

Subject: Why would you do that?
Body:

• Confirms the button was pressed
• Names the user
• Reassures everyone that this has been logged

This email exists purely to shame the action.

---

Why This Exists

• It solves no business problem
• It introduces unnecessary complexity
• It is intentionally overengineered
• It is fully documented

This solution demonstrates:

• Canvas Apps
• Power Automate
• SharePoint integration
• Azure Automation
• End-to-end orchestration

All in service of a button that should not be pressed.

🚀 The team is at it again – let’s get building! 🚀

Moving SharePoint List Items with a Canvas App, Power Automate & Azure Runbook

In this solution, I built a Canvas App that allows users to move items from one SharePoint list to another using a simple UI:
One button and 3 text fields.
Behind the scenes, the process is fully automated using Power Automate and an Azure Automation Runbook.

The goal is to keep the app simple for the user, while handling the heavy logic securely and efficiently in the backend.

How the Solution Works

Result
All items are successfully moved with a single click, no manual copying, no risk of partial moves, and no direct SharePoint permissions required in the app.

Canvas App
The user fills in four text fields (for example: source list, target list, item identifiers, or metadata) and clicks a button.

Power Automate Flow Triggered
The button triggers a Power Automate flow, passing the input values from the Canvas App as parameters for the Runbook.

Azure Automation Runbook Starts
The flow securely starts an Azure Automation Runbook, which contains the logic for handling SharePoint operations.

SharePoint List Processing
The Runbook:

Reads items from the source SharePoint list

Creates matching items in the target SharePoint list

Removes (or archives) the original items from the source list

---

Example Use Cases

• Archiving completed tasks
• Moving requests between workflow stages
• Separating active and historical data
• Bulk list management without direct SharePoint access

By combining a Canvas App with Power Automate and an Azure Runbook, this solution delivers a low-code user experience with enterprise-grade automation.
The user interacts with a simple interface, while the system handles complex SharePoint operations reliably in the background.

Canvas app

Power Automate

Runbook Powershell

Why We’re Sharing

At ACDC 2026, we believe that innovation happens faster when we collaborate. That’s why we’re excited to share our Minecraft Builder MCP Server with all participating teams. This isn’t just about fulfilling a badge requirement – it’s about creating a foundation that all teams can build upon.

Whether you’re working on voice-controlled building, IoT-triggered construction, AI-driven city planning, or any other creative Minecraft integration, our server and API can help you get there faster.

What We’re Sharing

Complete MCP Server Implementation

We’ve open-sourced our entire Model Context Protocol (MCP) server that connects AI coding assistants to Minecraft. This includes:

• Full Source Code: TypeScript implementation with comprehensive error handling
• Docker Support: Ready-to-deploy containerized solution
• Example Scripts: Working examples for building houses, towers, and castles
• Complete Documentation: Setup guides, API reference, and troubleshooting

GitHub Repository: https://github.com/miraculesx/ACDC404

Live REST API Access

Don’t want to run the server yourself? We’re hosting a public API endpoint that ALL teams can use:

http://ptacdc2026.norwayeast.cloudapp.azure.com:25611

This means you can start building in Minecraft right now without any setup. Just call our API with a simple HTTP request and you’ll be placing blocks in seconds.

Real-World Use Cases

Here’s how we imagine teams could use this:

Voice-Controlled Building System
If you’re building a voice assistant that responds to spoken commands, you can integrate our API to instantly build structures based on what users say. Imagine saying “build a castle at spawn” and watching it materialize in Minecraft within seconds.

IoT-Triggered Construction
Have sensors like our micro:bit that trigger building events? Connect them to our API through Azure Functions. When motion is detected, automatically build a tower. When a door opens, place a block. The possibilities are endless.

AI-Driven City Planner
Want an AI agent to design and build an entire city? Use our API to let GPT or other AI models plan layouts and then execute the construction automatically. Build entire neighborhoods with a single command.

Power Platform Integration
Building a low-code solution with Power Automate? Add an HTTP action that calls our API. Now your flows can build Minecraft structures based on form submissions, emails, or any other trigger.

Complete API Reference

All endpoints are available at: http://ptacdc2026.norwayeast.cloudapp.azure.com:25611

Building Structures

POST /api/build
Send a JSON body with structure type (house, tower, castle, or platform) and x, y, z coordinates. Optionally specify material.

Available Structures:

• house: 7x6x7 block house with door and windows
• tower: 5x20x5 tall tower
• castle: 20x15x20 castle with walls and towers
• platform: 10x1x10 flat platform

Block Operations

POST /api/block/place – Place a single block at specific coordinates with chosen block type
POST /api/block/break – Break a block at specific coordinates

Terrain Management

POST /api/terrain/clear – Clear an area between two coordinate points
POST /api/terrain/fill – Fill area with specific block type
POST /api/terrain/flatten – Flatten terrain in radius around center point

Bot Control

GET /api/bot/position – Get current bot position
POST /api/bot/goto – Navigate bot to specific location
POST /api/bot/look – Make bot look at specific position
POST /api/chat – Send chat message to Minecraft server

Technical Architecture

Our solution uses a multi-layer architecture:

AI Coding Assistant (GitHub Copilot, Claude) talks to MCP Server (Node.js/TypeScript) which talks to Minecraft Plugin (Java – Bukkit/Spigot) which controls a Mineflayer Bot in Minecraft Server (Java Edition 1.21).

The MCP server acts as a translation layer between high-level AI instructions like “build a castle” and low-level Minecraft commands that place thousands of individual blocks in specific positions.

Why Model Context Protocol (MCP)?

MCP is a protocol for connecting AI coding assistants to external tools and data sources. By implementing MCP, our server can work with multiple AI assistants, provide structured typed interfaces for building operations, enable natural language commands, and maintain context across multiple building operations.

Fair Use and Rate Limiting

To ensure the API remains available for all teams:

• Request Limit: approximately 5 requests per second per team
• Best Practice: Add 200-500ms delays between sequential requests
• Bulk Operations: Prefer batching when building multiple structures
• Contact Us: Need higher limits? Let’s talk!

Getting Started in 5 Minutes

Option 1: Direct API Usage (No Installation)

Test connection by calling the bot position endpoint. Then build your first structure by sending a POST request with structure type and coordinates. That’s it – you just built something in Minecraft!

Option 2: Clone and Run Locally

Clone our GitHub repository, install dependencies with npm, build with npm run build, and start with npm start. Then configure your AI assistant to use the MCP server by adding it to your MCP configuration.

Repository Contents

When you clone the repository, you get the full TypeScript source code, example scripts for building houses, castles and towers, Docker and docker-compose configurations, complete documentation, and all necessary dependencies.

Our Story: From Webcam to Minecraft

This MCP server is part of our larger ACDC 2026 solution that combines a physical Lego plate with color markers, MacBook webcam running OpenCV, micro:bit v1 with PIR sensor, Azure Functions for processing, Blob Storage for snapshots, and this MCP Server to translate everything into Minecraft builds.

The MCP server connects the digital world (Azure, sensors, AI) to the Minecraft world, creating a tangible representation of events.

Badges This Fulfills

Sharing is Caring: “Code, dataset or Api is made available for other teams”

• Public GitHub repository with full source code
• Live REST API accessible to all teams
• Complete documentation and examples
• Docker support for easy deployment

We’re also looking for: “Sensible contribution (pull request, integration) on a competing teams solution” – We’d love to integrate with your solution!

Want to Contribute?

We’re actively looking for teams to collaborate with! If you have an interesting use case or want to integrate this into your solution, we’d love to help with integration support, custom features, performance optimization, or cross-team collaboration.

Contact and Support

During ACDC 2026 Hackathon find us at Soria Moria Hotel, Holmenkollen – look for “404 No Diamonds Found” table sign.

• Online:
• GitHub Issues: https://github.com/miraculesx/ACDC404/issues
• Repository: https://github.com/miraculesx/ACDC404
• API Status: http://ptacdc2026.norwayeast.cloudapp.azure.com:25611/api/bot/position

Example Scenarios We’d Love to See

• Voice-Activated City Builder: “Alexa, build a medieval city”
• IoT Smart Home: Door sensor triggers castle wall construction
• Social Media Integration: Twitter mentions = building placement
• AI Urban Planner: Let GPT-4 design entire cities
• Gesture Control: Use Kinect/camera to “paint” structures in 3D space
• Music Visualizer: Build structures that react to music beats
• Game-ification: Points system that builds structures as rewards
• Educational Tool: Teach coding by building Minecraft structures
• Remote Collaboration: Multiple teams building in same world
• Time-Based Events: Scheduled constructions like New Year’s fireworks tower

Performance Characteristics

Based on our testing:

• Single Block Placement: approximately 50ms including network latency
• Small Structure (House): 2-3 seconds (49 blocks)
• Medium Structure (Tower): 5-7 seconds (500 blocks)
• Large Structure (Castle): 30-40 seconds (2000+ blocks)
• API Response Time: less than 100ms for most operations
• Concurrent Requests: Supports up to 10 simultaneous builders

License

This code is open source for ACDC 2026 hackathon participants. Feel free to use it in your solutions, modify and extend it, share it with other teams, and build commercial projects on top of it after the hackathon. No attribution required, but we’d love to know what you build with it!

Acknowledgments

This project uses amazing open-source libraries: Mineflayer for Minecraft bot framework, MCP SDK for Model Context Protocol implementation, Express for web framework, and TypeScript for type-safe JavaScript.

Special thanks to the ACDC 2026 organizers for creating an environment where sharing and collaboration are celebrated!

Final Thoughts

We believe that hackathons are not just about competition – they’re about pushing the boundaries of what’s possible together. By sharing our MCP server, we hope to save time for teams so they can focus on unique ideas instead of infrastructure, enable creativity by making Minecraft integration accessible to all teams, foster collaboration to build connections between teams and solutions, and raise the bar so when everyone has better tools, everyone builds better solutions.

We can’t wait to see what you build with it!

Let’s build something amazing together!

Team 404 No Diamonds Found
Arctic Cloud Developer Challenge 2026

Quick Reference

Essential Endpoints:

• POST /api/build with JSON body: structure (house, tower, castle), x, y, z coordinates
• POST /api/block/place with JSON body: x, y, z coordinates and block type
• GET /api/bot/position to get current position
• POST /api/chat with JSON body: message text

• Rate Limits:
• 5 requests per second per team
• 200ms minimum delay between requests

• Server Details:
• API URL: http://ptacdc2026.norwayeast.cloudapp.azure.com:25611
• Minecraft Server: ptacdc2026.norwayeast.cloudapp.azure.com:25565
• Region: Norway East (Azure)
• Uptime: 24/7 during hackathon

• Support Channels:
• GitHub Issues for technical problems
• In-Person at the hackathon
• Documentation at https://github.com/miraculesx/ACDC404

Updated: January 23, 2026, 00:30 CET