spec.md

Challenge Overview Welcome to the Learn AI Challenge series! Your mission is to explore AI and the Model Context Protocol (MCP) by building an innovative AI Agent application that leverages the Topcoder MCP server.

The agent can take many forms—chatbot, automation tool, research assistant, code generator, data visualization tool, or something entirely unique.

You are free to use open-source agents or develop your own from scratch. The only requirement is that the agent must utilize the Topcoder MCP server and deliver a meaningful, user-friendly experience through the server's tools and resources.

This is your opportunity to learn, innovate, and demonstrate your creativity and engineering expertise using cutting-edge AI technologies—plus earn rewards and community recognition.

Challenge Incentives Top 10 winners will receive cash prizes. Winners and top submissions will be awarded an "AI Explorer" badge on their Topcoder profiles. Selected high-quality submissions will be featured on the Topcoder Hugging Face organization page, providing recognition and exposure to the broader AI community. Challenge Details Technology Focus: Development of AI Agents using the Model Context Protocol (MCP) Submission Duration: 21 days Agent Type: Any form of intelligent application is allowed—such as chatbots, virtual assistants, research tools, code generators, or data visualization agents. Creativity: Participants are encouraged to push boundaries and design original, inventive AI applications. Functionality: The AI agent must address a clearly defined problem or purpose and deliver impactful, practical results. Implementation Requirements:

The AI agent must be designed to run within a Hugging Face Space. You can use any SDK or programming language, as long as it functions correctly in the Hugging Face Space environment. The agent must run smoothly on the default free-tier hardware (CPU Basic) provided by Hugging Face—no GPU usage required. It must connect to and interact with the Topcoder MCP server and deliver clear, purposeful results through an intuitive and user-friendly interface. Submission Requirements A fully functional AI Agent application, either as a downloadable codebase (zip file) or a publicly accessible Hugging Face Space link—or both. The submission must be based on a clearly defined use case that addresses a specific problem. Participants should also include a simple, clear document (as part of the submission) that outlines the problem being solved, the rationale behind the chosen use case, and how the AI agent addresses it. This clarity should also be reflected in the agent’s implementation and user experience. Accompanying documentation that clearly explains how to deploy, configure, and run the AI agent on Hugging Face Spaces. An optional demo video (up to 5 minutes) showcasing the agent’s core functionality and how it addresses the defined use case. What You Will Learn By participating in this challenge, you will:

Gain a practical understanding of AI agent architecture, development workflows, and prompt engineering techniques. Strengthen your hands-on skills using technologies such as TypeScript, Python, JSON, APIs, and Gradio in real-world scenarios. Learn to build, integrate, and test AI applications using the Model Context Protocol (MCP) server provided by Topcoder. Develop proficiency in working with data ingestion, backend logic, and designing clear and effective user experiences (UI/UX) for AI tools. Learn how to prepare, optimize, and deploy your application to Hugging Face Spaces using their CPU Basic environment. Improve your ability to define clear use cases, articulate the problem your solution addresses, and communicate that effectively through documentation and demonstration. Engage with the broader Topcoder AI community to gain visibility, collect feedback, and earn recognition through badges, publications, or prizes. Build portfolio-worthy work that demonstrates your ability to solve meaningful problems using modern AI tools. Learning Path & Plan This 3-week challenge is structured as a guided learning journey. Below is a comprehensive, curriculum-style blueprint divided into modules, each with a clear objective, tasks, and deliverables. This will help you progress from beginner to deployer by the end of the challenge.

Module 1: Foundations of AI Agents & MCP (Days 1–2) Objective: Understand the core principles of AI agents and how the Model Context Protocol (MCP) enables real-world AI integration.

What are AI agents? (Examples: chatbots, automation tools, assistants, research agents)

Core capabilities of agents: statefulness, prompt context, responsiveness, and output generation

Overview of the Model Context Protocol (MCP) and how it facilitates structured communication between users and AI models

Learn about transports like SSE and Streamable HTTP used by MCP

Understand how MCP connects to Topcoder’s public APIs and what kind of tools/data you can access

Recommended Course: Model Context Protocol (MCP) Course by Hugging Face

Covers how to build MCP clients Shows integration with Gradio Includes code walkthroughs, examples, and deployment steps Deliverable: Written summary explaining:

The type of AI agent you want to build How MCP can be used in that context Module 2: Development Environment Setup (Days 1–2) Objective: Get your local environment ready to build, test, and run MCP-powered AI agents.

Install and configure a suitable IDE (e.g., VSCode, Cursor) Set up the Topcoder MCP server endpoint ( https://api.topcoder-dev.com/v6/mcp/mcp ) in your IDE’s settings.json Install relevant SDKs and dependencies (e.g., TypeScript, Python, Gradio, Node.js, etc.) Use the MCP Inspector to validate server connection and test a basic query Recommended Resources:

Gradio Getting Started Guide (with code examples and UI integrations) VSCode Official Setup Instructions, Cursor Editor (AI-powered IDE) Topcoder MCP Inspector GitHub Deliverable:

A working development environment Screenshot or confirmation of successful test interaction with MCP server using MCP Inspector Module 3: Exploring MCP Server Capabilities (Days 1–2) Objective: Learn how to explore the Topcoder MCP server, understand available tools and data, and identify what can power your agent.

Understand the difference between SSE and Streamable HTTP transports in MCP. Launch the MCP Inspector and connect it to the Topcoder MCP endpoint ( https://api.topcoder-dev.com/v6/mcp ). Explore the public tools and resources available via the server. Review example requests and responses, and document the ones relevant to your intended use case. Determine the input and output formats for at least one useful endpoint. Recommended Resources:

Topcoder MCP Inspector GitHub SSE and HTTP Streaming - MDN Reference Deliverable:

A table listing at least 3 MCP tools or endpoints with their purpose, input, and expected output Screenshots or logs of actual request/response payloads from the MCP Inspector Module 4: Refine the Use Case & Design the Agent (Days 1–2) Objective: Revisit your original agent idea after exploring the Topcoder MCP server and finalize a well-defined use case and experience flow.

Reflect on your initial idea from Module 1 in light of the MCP tools and data you've explored Validate whether the original use case still makes sense or needs to be adapted Clearly define: The real-world problem you're solving Why it's meaningful How your agent will solve it using one or more MCP tools Create a user journey flow, wireframe, or basic mockup to visualize how users will interact with your agent Deliverable:

Finalized use case document with: Problem definition Target user or audience Description of solution and value proposition MCP tools or endpoints your agent will use UX mockup or user journey diagram that reflects the agent's intended experience. You can use v0.dev to quickly generate visually appealing mockups with the help of AI. Module 5: Building Agent Logic & MCP Integration (Days 2–3) Objective: Implement the core logic of your agent to communicate effectively with the Topcoder MCP server, retrieve data, and generate intelligent outputs.

Set up your project structure using a preferred language (Python, TypeScript, etc.) Choose your connection method (SSE or Streamable HTTP) and implement a request handler for MCP Integrate the MCP endpoint(s) you selected in Module 3 Process incoming data and prepare meaningful responses Apply prompt engineering principles to enhance agent output quality Ensure your logic runs efficiently on Hugging Face CPU Basic (no GPU dependencies) Recommended Resources:

Prompt Engineering Guide Example backend agent using Python with SSE + Hugging Face: MCP Agent Boilerplate (Python) Demonstrates how to: Connect to Topcoder MCP using SSE Build an async backend agent using FastAPI Deploy to Hugging Face with CPU basic config This is ideal if you're building a backend-only agent with no frontend SDK involved. EventSource API Reference: MDN Docs Guide](https://github.com/dair-ai/Prompt-Engineering-Guide) Example SSE integration (React or Node): MDN EventSource Docs Deliverable:

A backend agent logic module that: Successfully connects to and queries the MCP server Returns usable responses to the frontend Demonstrates use of at least one real MCP tool or endpoint A brief explanation (in your README) of how the MCP connection is implemented and which tools it uses Module 6: UI/UX Development (Days 2–3) Objective: Create an accessible, intuitive interface to showcase your AI agent’s capabilities.

Choose a simple UI framework such as Gradio, Streamlit, or a minimal HTML/JS frontend (Gradio recommended for ease of Hugging Face integration) Link the UI to your backend logic (built in Module 5) Focus on making input fields and output displays clear and accessible Provide contextual labels, input placeholders, and output formatting where helpful Consider adding a loading indicator or progress feedback if MCP requests take time Deliverable: A lightweight, working UI prototype that allows users to interact with your agent and see live responses from the MCP server

Module 7: End-to-End Testing & Debugging (Days 1–2) Objective: Ensure your agent is production-ready through comprehensive testing and optimization.

Perform full end-to-end testing: UI → backend → MCP → backend → UI Simulate real user interactions and input variations Identify and handle edge cases, unexpected input, and communication errors (e.g., timeouts, SSE disconnects) Add fallback behavior or helpful messages for errors Profile and optimize response time, agent feedback, and loading states Deliverable: A stable, polished, and bug-free agent that reliably handles diverse inputs and edge scenarios

Module 8: Deployment on Hugging Face Spaces (Days 1–2) Objective: Deploy your agent to a live environment and ensure it's accessible and stable.

Prepare requirements.txt and README.md with necessary dependencies and setup instructions Push your project to a new or existing Hugging Face Space Confirm successful deployment on the default CPU Basic hardware (no GPU) Perform smoke testing to validate end-to-end functionality Deliverable: A fully deployed Hugging Face Space (public link) or a repository that’s ready to be deployed without additional changes

Module 9: Documentation & Demo (Days 1–2) Objective: Ensure your project is easy to understand, use, and present.

Create a well-structured README that includes setup instructions, usage examples, and technical details Clearly articulate the use case and the problem your agent addresses (Optional) Record a 3–5 minute demo video walking through how your agent works Deliverable: Comprehensive documentation with an optional demo video

Module 10: Final Packaging & Submission (Day 1) Objective: Finalize and submit your agent project with all required materials.

Package your project as a zip file or provide a live public link (e.g., Hugging Face Space) Carefully review the challenge submission checklist to ensure everything is included Submit your entry via the challenge platform before the deadline Deliverable: A complete submission package that meets all criteria and is ready for judging

The Topcoder MCP Server The Model Context Protocol (MCP) server provided by Topcoder is hosted at: https://api.topcoder-dev.com/v6/mcp.

It supports two transport mechanisms for agent communication:

Server-Sent Events (SSE): https://api.topcoder-dev.com/v6/mcp/sse Streamable HTTP: https://api.topcoder-dev.com/v6/mcp/mcp Your agent must use one of these transports to interact with the MCP server. No authentication is currently required—your agent can connect and send requests without needing a token. The server exposes publicly available data and tools sourced from the Topcoder APIs. In future updates, we may introduce authenticated features and enhanced tools that require login or user tokens.

Review & Evaluation We will review submissions on an iterative basis. After completing each module, please upload your work (e.g., Document, link to GitHub repo, Hugging Face Space, or zipped files) and notify the challenge copilot by email, the copilot will reivew and share feedback over email.

You will typically receive feedback within 1–2 days, helping you improve and refine your work before progressing.

This optional collaborative review process ensures you stay on track and gives you the best chance of submitting a high-quality agent by the end.

Final Evaluation Criteria Your final submission will be judged based on the following:

Functionality & Stability (30%) – Does the agent work as intended across different inputs and edge cases? Use Case Relevance (20%) – How clearly defined and meaningful is the problem the agent addresses? MCP Integration (20%) – How effectively does the agent leverage the Topcoder MCP tools and transports? User Experience & Interface (15%) – Is the UI intuitive, responsive, and polished? Documentation & Demo (10%) – Is the README clear? Does the optional video explain the agent effectively? Originality & Creativity (5%) – Is the idea novel or uniquely executed? High-scoring submissions typically demonstrate smooth functionality, a clear purpose, practical use of MCP tools, and thoughtful design.