PORTAL MCP

What Is It

PortalMCP (Model Context Protocol) is Portal Foundation's smart contract automation layer, built for AI agents. It transforms the traditional development stack into a natural language-powered, modular environment—bridging Claude, Solidity, EVM chains, and deployment pipelines.

From idea to deployed dApp, PortalMCP lets anyone build, test, simulate, and ship contracts or entire applications with minimal technical effort.

Vision

Empower developers, founders, and AI agents to co-create decentralized applications by:

• Abstracting blockchain development into modular AI workflows
• Enabling smart contract generation, testing, deployment, and frontend creation via natural language
• Supporting AI-first infrastructure for Ethereum and compatible chains

Why It Matters

Writing and deploying smart contracts has always required deep technical knowledge. PortalMCP removes that barrier—letting anyone, including AI agents, participate in building the decentralized internet.

This means:

• Faster prototyping and iteration
• Safer contracts through simulation and agentic testing
• Easier onboarding for founders, creators, and non-coders
• Decentralized development at scale

Problem & Solution

The Problem:

• Blockchain development is complex, fragmented, and highly technical
• Non-coders and AI agents struggle to interact with low-level tooling
• Most IDEs lack natural language and agentic functionality

Our Solution:

• AI-native architecture: Claude and LLMs call MCP endpoints
• Natural language interface for building, testing, and deploying contracts
• Secure user-signed transactions with no key exposure
• Modular architecture that supports continuous updates

How It Works

1. A user or agent types a natural language prompt ("Deploy NFT collection called PortalPass")
2. Claude interprets and triggers MCP tools (e.g. eth_create_nft_collection, eth_mint_nft)
3. The server returns compiled transactions for the user to sign
4. The bot tracks progress and deploys the frontend automatically

Key Features

💻 Smart Contract Pipeline

• eth_generate_contract: Generate custom Solidity code
• eth_compile_contract: Compile to ABI + bytecode
• eth_deploy_contract: Deploy to EVM chains
• eth_call_contract: Read any function (e.g. symbol(), balanceOf())
• eth_send_transaction: Write or send ETH

💰 Token Tools

• eth_create_token: Generate ERC-20 contracts
• eth_get_token_balance: Read token balances
• eth_transfer_token: Prepare token transfer

🎨 NFT Tools

• eth_create_nft_collection: Deploy ERC-721 collections
• eth_mint_nft: Mint NFT to any wallet
• eth_get_nft_owner: Get current owner of an NFT ID

🌟 DeFi Tools

• eth_create_staking_contract: Deploy staking logic
• eth_stake_tokens: Stake ERC-20s
• eth_swap_tokens: Build swap transactions (DEX integration)

🚀 Simulation, Verification, and Deployment

• Pre-signature simulation of any contract call
• Multi-network support (mainnet + testnets)
• Manual signature flow (non-custodial)

🔬 Frontend + IDE

• generate_frontend: Build a basic UI connected to deployed contracts
• link_to_contract: Bind frontend to contract address
• deploy_dapp: Ship the full dApp live
• portalIDE: Code editor with Claude integration

Security Model

• Non-custodial: all transactions require external wallet signature
• All actions pre-simulated for safety
• Tools are read/write scoped
• No private keys or blind execution

Use Cases

• Deploying DAO or governance contracts
• Creating NFT drops with mint functionality
• Launching staking or liquidity programs
• Building token-gated apps or airdrop tools
• Educational training labs or hackathons

Roadmap

Technology Stack

• Claude + GPT-4 for natural language understanding
• FastAPI + Node.js for MCP endpoints
• Solidity / Foundry for contract compilation
• Ethers.js/Web3.js for transactions
• Portal Wallet integration for secure signing

Competitive Advantages

• Natural language-first blockchain IDE
• Seamless agent-to-MCP interaction
• Multi-chain compatibility
• Modular architecture (easy to expand)
• Claude-ready tooling for Web3 agents

Investment Opportunity

PortalMCP is not just a product—it's a protocol layer for autonomous dApp creation.

• LLM-first developer tooling is still new
• Web3-native IDEs are still early
• Agentic contract generation unlocks high-leverage workflows

Investors benefit from:

• Long-tail monetisation (AI agents using MCP)
• On-chain value creation and platform fees
• Licensing MCP to other LLM-based platforms

By enabling Claude to act directly on-chain, PortalMCP builds the foundation for autonomous, low-code Web3 development at scale.

🔧 Installation: PortalMCP

Prerequisites

• Node.js v16 or higher
• npm or yarn
• An Ethereum wallet (MetaMask recommended)
• Access to Claude API (Anthropic)

Setup Instructions

1. Clone the PortalMCP repository

git clone https://github.com/your-username/portalmcp.git
cd portalmcp

2. Install dependencies

npm install

3. Create your .env file

cp .env.example .env

4. Configure your API keys in .env

ANTHROPIC_API_KEY=your_claude_api_key
INFURA_API_KEY=your_infura_key
# or
ALCHEMY_API_KEY=your_alchemy_key

5. Build the project

npm run build

6. Start the PortalMCP server

npm start

🧠 Claude Integration

To connect Claude to PortalMCP, update your Claude config (claude_desktop_config.json) like this:

{
  "mcpServers": {
    "portalmcp": {
      "command": "node",
      "args": ["path/to/portalmcp/dist/index.js", "--network", "sepolia"]
    }
  }
}

This setup lets Claude interact with PortalMCP using natural language prompts like:

• "Create an ERC-20 token with supply 1M"
• "Deploy this NFT collection"
• "Swap USDC to ETH"