from mcp.server import Server
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build
import json

app = Server("gmail-mcp")

SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']

def get_gmail_service():
    flow = InstalledAppFlow.from_client_secrets_file(
        'credentials.json', SCOPES)
    creds = flow.run_local_server(port=0)
    return build('gmail', 'v1', credentials=creds)

@app.resource("gmail://inbox")
async def read_inbox():
    service = get_gmail_service()
    results = service.users().messages().list(userId='me', maxResults=10).execute()
    messages = results.get('messages', [])

    inbox_data = []
    for msg in messages:
        data = service.users().messages().get(userId='me', id=msg['id']).execute()
        headers = data['payload']['headers']
        subject = next((h['value'] for h in headers if h['name'] == 'Subject'), 'No Subject')
        inbox_data.append({'id': msg['id'], 'subject': subject})

    return TextContent(text=json.dumps(inbox_data))

@app.tool("send_email")
async def send_email(to: str, subject: str, body: str):
    service = get_gmail_service()
    message = {
        'raw': base64.urlsafe_b64encode(
            f"To: {to}\nSubject: {subject}\n\n{body}".encode()
        ).decode()
    }
    result = service.users().messages().send(userId='me', body=message).execute()
    return f"Email sent: {result['id']}"

if __name__ == "__main__":
    asyncio.run(app.run())

from mcp.server import Server
from slack_sdk import WebClient
import os

app = Server("slack-mcp")
slack_client = WebClient(token=os.environ['SLACK_BOT_TOKEN'])

@app.resource("slack://channels")
async def list_channels():
    result = slack_client.conversations_list()
    channels = result['channels']
    return TextContent(text=json.dumps(channels))

@app.tool("send_slack_message")
async def send_message(channel: str, message: str):
    result = slack_client.chat_postMessage(
        channel=channel,
        text=message
    )
    return f"Message sent to {channel}: {result['ts']}"

@app.tool("read_channel_messages")
async def read_channel(channel: str, limit: int = 10):
    result = slack_client.conversations_history(
        channel=channel,
        limit=limit
    )
    messages = result['messages']
    return TextContent(text=json.dumps(messages))

if __name__ == "__main__":
    asyncio.run(app.run())

from mcp.server import Server
from github import Github
import os

app = Server("github-mcp")
gh = Github(os.environ['GITHUB_TOKEN'])

@app.resource("github://repos")
async def list_repos():
    user = gh.get_user()
    repos = user.get_repos()
    repo_data = [{'name': r.name, 'url': r.html_url, 'stars': r.stargazers_count} for r in repos]
    return TextContent(text=json.dumps(repo_data))

@app.tool("create_github_issue")
async def create_issue(repo_name: str, title: str, body: str):
    repo = gh.get_user().get_repo(repo_name)
    issue = repo.create_issue(title=title, body=body)
    return f"Issue created: {issue.html_url}"

@app.tool("list_open_issues")
async def list_issues(repo_name: str):
    repo = gh.get_user().get_repo(repo_name)
    issues = repo.get_issues(state='open')
    issue_data = [{'number': i.number, 'title': i.title} for i in issues[:10]]
    return TextContent(text=json.dumps(issue_data))

if __name__ == "__main__":
    asyncio.run(app.run())

@app.resource("zameen://listings")
async def get_listings(city: str, min_price: int, max_price: int):
    # Scrape or API call to Zameen.pk
    listings = [...]
    return TextContent(text=json.dumps(listings))

@app.tool("analyze_real_estate_market")
async def analyze(city: str, property_type: str):
    # Analyze price trends, demand
    return "DHA Karachi: 15% YoY appreciation"

@app.tool("send_whatsapp")
async def send_whatsapp(phone: str, message: str):
    # Call WATI API
    response = requests.post(
        "https://api.wati.io/api/v1/sendSessionMessage",
        json={"phoneNumber": phone, "message": message}
    )
    return response.json()

FROM python:3.11
WORKDIR /app
COPY server.py requirements.txt ./
RUN pip install -r requirements.txt
CMD ["python", "server.py"]

Deploy your MCP as serverless function. Instant scaling.

python server.py &
# Runs on localhost:3000