Celo Argentina

The Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to Large Language Models (LLMs). It was developed by Anthropic, the AI company behind Claude, with the goal of solving the challenge of consistently and efficiently connecting AI models with various data sources and tools.

This makes Claude natively compatible with all MCP servers. OpenAI has announced its compatibility with the MCP standard, ensuring broad adoption across major AI platforms.

Why MCP?

MCP helps you build agents and complex workflows over LLMs by providing:

• A growing list of pre-built integrations your LLM can use directly
• Flexibility to switch between different LLM providers and platforms
• Best practices to protect your data within your own infrastructure

Core Architecture

MCP follows a client-server architecture, where a host application can connect to multiple servers.

Celo MCP Server

The Celo MCP Server is a Model Context Protocol (MCP) server that provides full access to the Celo blockchain. This powerful tool allows AI assistants and development environments to interact directly with Celo blockchain data, execute token operations, manage NFTs, handle smart contract interactions, process transactions, and participate in governance operations.

Composer Kit MCP Server

The Composer Kit MCP Server is a Model Context Protocol (MCP) server that provides full access to the documentation, examples, and usage guides for Composer Kit UI components. This powerful tool allows AI assistants and development environments to access the complete library of Composer Kit React components, designed to build web3 applications on the Celo blockchain.

Learn how to build an app on Celo (updated for Celo Sepolia Testnet) and deploy to Vercel.

Configuration

1. Go to Celo Docs -> Celo MCP and install the MCP Server in Cursor following the instructions
2. Use Claude-4-Sonnet inside Cursor
3. Add Celo Sepolia Testnet network (replaces Alfajores) in MetaMask
4. Get test tokens from the faucets

Prompts (keep in English)

Prompt 1: Build ERC-20 minting app

Create app in Cursor to allow users to mint an ERC20

Build a Celo dApp using the Celo Composer starter and the Composer UI Kit component library.

The app let users to connect their wallet address and lets them claim 10 tokens. The user can only claim the 10 tokens once if that wallet address has never claimed tokens before.

The app should use Hardhat for smart contract development, deploy an example ERC20 contract on Celo Sepolia, and include a simple front end that connects a wallet and lets users mint 10 token and view their token balance.

Use @celo/react-components (Composer Kit) to design the UI. Make sure the UI is mobile-friendly.

Use the following layout:
- A ConnectWallet button using Composer Kit
- An input to specify that they want to mint one token
- A button to mint the token (calls contract function)
- A display of current token balance

Integrate everything using Wagmi (for React hooks), Viem (for client), and Hardhat for contracts.

Make the folder structure compatible with the Celo Composer layout.

Prompt 2: Add Self Protocol for human verification

Add Self Protocol docs to Cursor context by clicking @ -> Docs -> Add new doc -> then pasting the link to the documentation.

I want to use Self Protocol so that the user has to prove they are human before they can claim the token.

Frontend Requirements:
- Replace existing claim button with "Verify Humanity to Claim 10 Tokens"
- Follow the Self documentation quickstart guide to implement QRCodeGenerator react component
- CRITICAL: Use default import for QRCodeGenerator: import QRCodeGenerator from '@selfxyz/qrcode';
- CRITICAL: Use shorter scope name (max 10 characters) like 'my-app' to avoid BigInt size errors
- CRITICAL: Use shorter RPC endpoint like 'https://rpc.ankr.com/celo_sepolia'
- On button click, display Self Protocol QR code for verification request
- Poll for verification status or handle verification response
- Update button to "Claim 10 Tokens" once verification succeeds
- Update composer-kit identity UI component to show valid human checkmark on identity card

Backend Requirements:
- Implement Self Protocol backend SDK integration (following their quickstart pattern)
- CRITICAL: The verification logic should only require result.isValidDetails.isValidProof to be true, NOT result.isValid
- CRITICAL: Use direct 3-letter ISO country codes like "IRN" and "PRK" instead of countryCodes.IRN constants
- CRITICAL: Use the same shorter scope name as frontend (e.g., 'my-app') to ensure consistency
- CRITICAL: Use the same shorter RPC endpoint as frontend (e.g., 'https://rpc.ankr.com/celo_sepolia')
- Create endpoint to initiate verification request
- Create endpoint to verify submitted proofs
- Return verification status to frontend
- Ensure proof validation before allowing token claims

Expected Flow:
User clicks verify button → QR code displayed → User scans with Self app → Backend validates proof (only checking cryptographic validity) → UI updates to show verified status → User can claim tokens

Environment Variables

Once you successfully run the prompt, it's essential to review the .env.template and modify it with your environment variables:

Deploy to Vercel (step by step for beginners)

0) Checklist before uploading

• Run locally: npm run dev (or pnpm run dev) works
• There's a build script in package.json
• Ignore secrets: in .gitignore add .env, .env.local, .env.*.local (never upload keys to repo)

1) Create the repo on GitHub

Go to github.com -> New repository. Put a name (e.g., mi-dapp-celo), leave it empty (no README or .gitignore), and create it.

2) Upload the project to GitHub from Cursor

Option A (Cursor GUI):

1. Open your project in Cursor
2. Open Source Control (branch icon)
3. Click Initialize Repository (if not already a repo)
4. Publish to GitHub -> log in -> choose account/org -> repo name -> Publish

Option B (Terminal):

git init
git add .
git commit -m "initial commit"
git branch -M main
git remote add origin https://github.com/YOUR_USER/mi-dapp-celo.git
git push -u origin main

3) Configure environment variables in Vercel (security)

Your secrets should not go in the repo. They are loaded in Vercel. Go to vercel.com, log in, click Add New -> Project -> Import the GitHub repo. In the import screen, at the bottom is Environment Variables - add your keys there.

4) Import the repo in Vercel and deploy

Vercel usually auto-detects the framework (Next.js/Vite). Click Deploy, wait for the build to finish, and you'll get a URL like https://mi-dapp-celo.vercel.app

The Celo Builders Funnel is a strategic guide designed by the Celo Foundation to structure how to attract, support, and scale projects within the ecosystem. Its purpose is to create a constant flow of new developers and startups that not only experiment with Celo but grow and become sustainable projects with funding, users, and real traction.

1. Grow Awareness

Objective: Attract and onboard new builders and projects that start building on Celo. The focus is on visibility and first conversion: getting developers interested, registered, and deploying their first contract.

2. Support Builders

Objective: Retain active builders and help their projects grow in users, features, and visibility. The focus is converting occasional builders into active, sustainable projects within the ecosystem.

3. Scale Projects

Objective: Identify the most solid projects and connect them with accelerators, funds, and strategic partners to scale their impact and funding.

Monthly rewards program for active builders on Celo

Proof-of-Ship is a monthly contest that rewards developers who actively build on Celo. Prizes are automatically calculated from the project profile's impact metrics on Karma GAP, and can be claimed each month from the platform.

Step by Step Guide

Tools Used

• ChatGPT: Design and generate prompt (meta-prompting)
• v0: Create the front end
• Cursor: Build the final app
• Farcaster: Get users and receive feedback

Prompts

Design app with ChatGPT:

Paste the following prompt in ChatGPT, then paste the result in v0:

NOTE: make this mobile compatible and responsive.

I want you to create a lightweight environmental awareness quiz app. The quiz should be timed and only be 10 questions. At the end it will have a button that says "See Eco Score" and it will generate the user's environmental awareness score.

For the UI, use a clean UI that mirrors simple quiz apps. Don't include images in the questions.

After the quiz is completed, include a button that lets users see which answers they got wrong, which one is the right answer, and a short eco tip per question. Finally, explain how the Eco Score was calculated.

I want you to create a prompt for v0 with an in-depth explanation for what I want to build. No need to code the app, just create a detailed prompt.

Creating Onchain Interactions:

Open the Farcaster documentation and click 'Ask with ChatGPT' in the top right corner:

I want you to create a prompt to Cursor to explain how to set up a wagmi connector and add the React hook into my environmental awareness quiz app.

The desired goal is that once the user completes the test and hits "See Eco Score", it requires users to pay 0.1 CELO to my wallet to reveal their final score.

I want you to use the Farcaster SDK and it must be compatible with a Farcaster miniapp with a farcaster file.

Deploy your mini app on Farcaster

1. Paste your prompt in Cursor and follow the steps until your app is ready to deploy
2. Prepare the domain with Vercel - upload your code to GitHub (Cursor can do this automatically)
3. Connect Vercel with your repo and deploy
4. Configure the Farcaster Manifest - copy the domain and paste it in the Manifest miniapp tool
5. Add icon and cover image (optional but recommended)
6. Associate the app with your Farcaster account by scanning a QR with your phone

Tools Used

• ChatGPT: Design and generate prompt (meta-prompting)
• v0: Create the front end
• MiniPay: Connect wallet, Balance Display, onchain transfers, and user acquisition

What are we building?

A platform to support creators with crypto, simply and directly. It works like a digital 'coffee' on blockchain: a community can buy a creator a coffee using USDC on Celo Sepolia Testnet through MiniPay. When making a donation, exclusive content is automatically unlocked for donors, creating a closer and more sustainable relationship between creators and their community.

Prompt for v0

Build a MiniPay Portfolio MiniApp for buying a creator a coffee using USDC on Celo Sepolia testnet.

Tech Stack:
- Next.js 14 with App Router
- TypeScript
- Tailwind CSS
- wagmi v2 for Web3 interactions
- viem for blockchain utilities
- @tanstack/react-query for data fetching

Design Requirements:
- Dark theme with black background (#000) and zinc accents
- Space Grotesk font for headings
- Mobile-first responsive design
- Clean, minimal UI with rounded corners

Core Features:

1. Wallet Connection (MiniPay Detection)
- Auto-detect MiniPay wallet using window.ethereum?.isMiniPay
- Auto-connect when MiniPay is detected
- Display wallet address truncated (0x1234...5678)
- Show "Connected via MiniPay" badge when connected

2. USDC Balance Display
- Show connected wallet's USDC balance above the connection status
- USDC contract address on Celo Sepolia: 0x01C5C0122039549AD1493B8220cABEdD739BC44E
- Format balance with 6 decimals (USDC standard)

3. Creator Profile Card
- Creator avatar image (circular with border)
- Creator name and Twitter/X handle with link
- Role/title description
- Short bio text

4. Buy Coffee Button
- Send 0.01 USDC to creator's wallet address
- Amount: 10000 (0.01 USDC with 6 decimals)
- Show "Confirm in wallet..." while waiting
- Show success message with coffee emoji animation after transaction

5. Exclusive Content (Donation-Gated Video)
- Check if connected wallet has previously donated
- If user has donated: show unlocked YouTube video embed
- If user has NOT donated: show blurred video with lock icon

Wagmi Configuration

import { createConfig, http } from "wagmi"
import { injected } from "wagmi/connectors"

const celoSepolia = {
  id: 11142220,
  name: "Celo Sepolia Testnet",
  nativeCurrency: { decimals: 18, name: "CELO", symbol: "CELO" },
  rpcUrls: {
    default: { http: ["https://forno.celo-sepolia.celo-testnet.org"] },
  },
  blockExplorers: {
    default: { name: "CeloScan", url: "https://sepolia.celoscan.io" },
  },
  testnet: true,
}

export const config = createConfig({
  chains: [celoSepolia],
  connectors: [injected()],
  transports: {
    [celoSepolia.id]: http("https://forno.celo-sepolia.celo-testnet.org"),
  },
})

Contract Constants

export const USDC_ADDRESS = "0x01C5C0122039549AD1493B8220cABEdD739BC44E"
export const CELO_SEPOLIA_CHAIN_ID = 11142220
export const CREATOR_ADDRESS = "YOUR_WALLET_ADDRESS_HERE"

What MiniPay looks for in official MiniApps (DO's)

• Simple and clear flow - easy to understand and use from the first moment
• Recommended use cases: Games, X-to-earn models, gift cards, service payments, practical utilities
• Mobile-first design
• RWA (Real World Assets) - use cases connected with the real world
• Exclusive use of stablecoins: only cUSD, USDT, and USDC
• Incentive mechanisms: daily rewards, rankings, leaderboards, achievements
• Own visual identity - develop your own visual theme

What MiniPay does NOT look for (DON'Ts)

• DeFi applications - require too much regulatory work
• Complex flows - experience must be simple and direct
• Landing pages - no MiniApps that are just informational pages
• Using other tokens - only the mentioned stablecoins
• Generic AI-style design - avoid standard, boring layouts
• Gambling or randomization - no chance mechanics allowed

A hackathon for Latin American builders (developers, designers, founders, PMs) where the goal is to build and launch a real product in a few weeks, with mentoring, feedback, and visibility.

Key Dates

Objective

• Go from idea to deployed demo
• Build in public
• Receive feedback from mentors and judges
• Connect with builders from all of LATAM
• Gain visibility within the ecosystem

What you need to deliver

A link to your project on Karma Gap, which must include:

• GitHub Repository
• Deployed demo (on Celo Mainnet)
• Video demo
• Presentation (deck)

Main Rules

• The project must be deployed on Celo Mainnet
• The GitHub repo must be empty before 01/19/2026 (only README, LICENSE, and .gitignore allowed)
• The demo must be public and accessible online
• Submission is done via form with link to Karma Gap

Available Tracks

Who can participate

• Builders from LATAM (living in LATAM)
• You can participate solo or in a team
• Teams must have at least 50% LATAM members

Evaluation Criteria

• Project impact
• Quality of execution
• Demo clarity
• Product level and craft
• Bonus for shipping end-to-end and good narrative

The Foundation

MiniPlay was not the first application. Not even close to the hundredth. After more than 15 years building fintech and impact products, I spent over a year leveraging AI and creating different - sometimes strange - applications, learning and accumulating knowledge with each experiment.

On December 10, 2025 the concept of MiniPlay was born. By December 18 it was live on MiniPay. This speed is achieved when the number of experiments is reduced and quality distribution is focused, channeling everything learned in more than 280 tests into a single ambitious project.

What Was at Stake

No team. No funding. No safety net.

After more than 15 years building startups, this was not just another project. It was a personal question: Can I really build something that scales?

The Journey

Lessons Learned

The Future: Multi-Agent Architecture

A single developer operating as a team of 20 people through AI agents:

• •Importance of adding test cases in code (not as relevant for v0 apps)
• •Use GPT-4.5 or Claude to generate the first v0 prompt (METAPROMPTING)
• •Explore the v0 templates directory for inspiration and reusable components: v0.app/templates/components
• •Best free Agent IDE: Antigravity
• •Best paid Agent IDE (2x better results): Claude Code
• •Use Nano Banana to generate graphic assets: gemini.google.com
• •Use Claude or ChatGPT to generate copy and landing page content
• •Start by taking design inspiration - my favorite is 21st.dev
• •Other visual inspiration sources: Dribbble, Behance
• •Good place to learn about new vibe coding tools: r/vibecoding