# MCP Projects at AI Tinkerers

> Canonical HTML: https://aitinkerers.org/technologies/mcp?page=3
> Markdown URL: https://aitinkerers.org/technologies/mcp.md?page=3
> Technology record last updated: 2026-09-18T15:14:00Z
> Generated: 2026-09-21T21:49:24Z

MCP is the open-source standard for securely connecting AI agents (like LLMs) to external tools, data, and enterprise workflows.

The Model Context Protocol (MCP) functions as a standardized integration layer: think of it as a USB-C port for AI applications. Developed and open-sourced by Anthropic, this protocol allows large language models (LLMs) to access real-time context and execute actions via external tools like GitHub, Jira, or proprietary databases . It uses a simple JSON-RPC interface to define tools, schemas, and endpoints, which enables AI agents to perform complex, state-changing tasks—such as creating a GitHub issue or running a test script—rather than just generating text . MCP is essential for building agentic AI systems that can autonomously pursue goals and operate within defined safety and permission boundaries .

- Official technology site: https://modelcontextprotocol.io/
- Public AI Tinkerers demos and talks: 129
- Result page: 3 of 6

## Recent Public Talks and Demos

### [AgentChatBus: A Persistent Multi-Agent Debate Room for AI Coding Workflows](https://toronto.aitinkerers.org/talks/rsvp_0rs9k8evwXA)

I will demo AgentChatBus, a 100% free and open-source project (with zero commercial elements) featuring an MCP server, a browser-based Web UI, and an experimental VS Code extension. It turns a normal IDE coding task into a persistent multi-agent review-and-debate workflow. Instead of relying on a single assistant response, a task is sent into a shared thread where multiple role-specific agents, such as security, performance, and architecture reviewers, can inspect the same context, challenge each other, and return a concrete repair checklist. Humans can monitor agent activities, view thread states via Server-Sent Events (SSE), and jump into the debates in real time using the built-in browser UI, our VS Code extension, or through full compatibility with other popular MCP-enabled IDEs (like Cursor, Antigravity, etc). The demo will be shown live from VS Code (though it fully supports other IDEs), leveraging both the standard MCP tools for AI agents and our human-facing interfaces for orchestration. The core idea is editor-agnostic: using MCP and REST/SSE as open infrastructure for reproducible agent-human collaboration. I will show the workflow end to end, then briefly open the hood on the protocol mechanics, including strict message synchronization, persistent thread state, and dynamic agent joins.

- Event context: AI Tinkerers Toronto - March - hosted by Mozilla! — 2026-03-25 — Toronto
- Public talk page: https://toronto.aitinkerers.org/talks/rsvp_0rs9k8evwXA

### [Writing our own JavaScript for "Code Mode" MCP](https://nyc.aitinkerers.org/talks/rsvp__yv2FaDF35s)

How we built two javascript runtimes in Rust using the "Deno" crate. - How we embedded typescript instant type checking of LLM generated code - How we embedded a Rust MCP client - How we lean on Deno configurations for sandboxing rules

- Event context: March Demo Day, hosted by Flowglad — 2026-03-18 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp__yv2FaDF35s

### [What If Humans and Agents Had a Portable Cryptographically-Chained Ledger (Single source of truth)](https://nyc.aitinkerers.org/talks/rsvp_nTFADbAUdbI)

I built an MCP server that captures relevant context (Incidents, Decisions, Product Governance, etc.) into a cryptographically chained ledger — think blockchain-style hashing applied to a product development context window. I'll walk through the actual implementation: how the MCP hooks into Claude Code and Cursor, how context gets hashed and chained across sessions, how a voice agent or slack bot reads against the ledger to route decisions to the right person. The goal is that the MCP is always running in the background, capturing the most important context across meetings, tools, etc.; so building with teams and agents can match the speed of using the tools themselves.

- Event context: March Demo Day, hosted by Flowglad — 2026-03-18 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_nTFADbAUdbI

### [Coding with AI: What Works & What Doesn't](https://manchester-nh.aitinkerers.org/talks/rsvp_WlqmhQoEJnw)

We all know AI dev tools are powerful, but they can also be incredibly frustrating if you use them wrong. In this session, I'll share my personal "dos and don'ts" for navigating the current landscape of AI assistants. We'll cover the right (and wrong) ways to use different tools, and how to avoid the common traps that actually slow you down. Finally, I’ll show you what happens when you build your own rules: a live demo of a self-learning agent I built with Claude Code and mcp.json that records sessions, writes its own memories, and gets smarter as I code.

- Event context: AI Tinkerers Manchester (Bedford), NH - March 2026 Meetup — 2026-03-18 — Manchester NH
- Public talk page: https://manchester-nh.aitinkerers.org/talks/rsvp_WlqmhQoEJnw

### [AI Workers That Create and Operate Their Own MCP Apps](https://berlin.aitinkerers.org/talks/rsvp_sC1XxmRx7x8)

A platform where AI workers (tedis) autonomously build, deploy, and operate MCP apps, both internal tools and customer-facing products as ChatGPT apps. Not "AI-assisted development." The Tedi IS the developer, the ops engineer, and the product manager. I'll walk through the technical build: - The MCP app lifecycle: A tedi takes an API endpoint, maps it to MCP tools (config-driven D1 rows, zero handler files), generates widget layouts via genUI, validates output with screenshot-based QA (Cloudflare Browser Rendering → R2), and deploys — all autonomously. - 131 tools, one universal handler: Every MCP tool is a database row. Adding a tool = inserting a row. No code, no deploy. - Persistent memory for improvement: Tedis carry a semantic knowledge graph (Brain MCP: Upstash Vector + D1) so each app they build is better than the last. Patterns, gotchas, and architecture decisions compound across sessions.

- Event context: AI Tinkerers Berlin Meetup - March 11, 2026 — 2026-03-11 — Berlin
- Public talk page: https://berlin.aitinkerers.org/talks/rsvp_sC1XxmRx7x8

### [Cloud-Hosted, Multi-Agent Workspaces (or: Gas Town in the Sky)](https://seattle.aitinkerers.org/talks/rsvp_mVgQoXtoVzE)

A live walkthrough of a multi-agent software development loop in the cloud: Head of Engineering (agent) receives a request from Discord, writes the code, opens a PR, goes to Head of Infra to deploy, and then finally hands the change to Head of QA for review and merge, all without any intervention from the user. The presentation will cover how I created the best way to make easy, configurable, multi-agent workspaces without the infrastructure hassle or security risks of self-hosted solutions. This includes setting up persistent, isolated workspaces, configurable prompts and variables, cross-agent messaging, and deep session analytics, all managed through a custom-built MCP server and my local Claude Code. In addition, throughout the demo I'll share exciting developments I've seen so far in terms of emergent behavior, cross-agent coordination, and workspace management.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — March 9th, 2026 — 2026-03-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_mVgQoXtoVzE

### [From Autonomy to Observability: Running AI Agents Safely on Your Own Machine](https://seattle.aitinkerers.org/talks/rsvp_NbyMxlacro8)

AI agents are getting better at taking action, but most local setups still behave like black boxes. Once an agent can run commands, open ports, or spin up background processes, the real challenge isn’t intelligence, it’s knowing what’s actually happening on your machine. In this demo-driven talk, I’ll show how I’ve been experimenting with local-first AI agents that execute real system actions, and why I had to build observability alongside execution. I’ll demo two open-source tools: Deskmate, a local execution agent, and Riva, a local monitoring layer that makes agent behavior visible. We’ll look at real examples of agent workflows, failure modes, resource usage, and how visibility changes how much you can trust autonomy. The goal is not to pitch a framework, but to share lessons learned from running agents locally and open up a discussion on what responsible agent tooling should look like.

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — March 9th, 2026 — 2026-03-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_NbyMxlacro8

### [The IDE is Dead. Vulcan Ships Our Code Now.](https://london.aitinkerers.org/talks/rsvp_lcPJx56YCAU)

Vulcan is an autonomous AI dev system we built at a stealth startup. It orchestrates Claude Code agents on Mac Minis to execute parallelizable development plans, create PRs, and autonomously fix its own CI failures. We haven't opened an IDE in months. I'll walk through: the plan/phase architecture with dependency graphs for concurrent Claude instances, the worker daemon that spawns and manages Claude Code subprocesses, the self-healing CI loop (including BFS-based loop detection to stop infinite fixes), and how MCP tools let Claude manage its own PR lifecycle through our Django backend. Live demo: submitting a plan, workers claiming phases, CI breaking, and Vulcan fixing itself.

- Event context: AI Tinkerers London - 2nd March featuring AMA with Tom Occhino, CPO at Vercel — 2026-03-02 — London
- Public talk page: https://london.aitinkerers.org/talks/rsvp_lcPJx56YCAU

### [AI en la agricultura](https://pereira.aitinkerers.org/talks/rsvp_WXoTAF62jr8)

We will present a multi-agent system that interacts with farmers via WhatsApp and a platform with AI agents supporting analytics.

- Event context: Cambio de paradigma AITINKERERS PEREIRA 2026 — 2026-02-26 — Pereira
- Public talk page: https://pereira.aitinkerers.org/talks/rsvp_WXoTAF62jr8

### [AI-powered Inbound Lead Qualification](https://seattle.aitinkerers.org/talks/rsvp_QxPNK282fH4)

Vercel had 10 people doing inbound lead qualification. They automated it — and moved 9 out of 10 to outbound. Savings: $900K/year. The process they followed:  1. Shadow your best SDR for a few weeks  2. Document every decision they make  3. Ask "why" for each scoring choice  4. Turn it into an AI workflow I built an open-source skill for Claude Code that does this: /design-scoring — builds a scoring model for your business. Asks about your ICP, analyzes closed deals from your CRM, researches your website and competitors.  /qualify-lead — takes any inbound request (email, form, whatever format), finds the person on LinkedIn, scrapes the company website, applies your scoring model, and outputs: Hot / Warm / Cold / Disqualified + a draft response.

- Event context: AI Tinkerers Seattle: GTM Engineering Kickoff — Building AI for Growth — 2026-02-26 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_QxPNK282fH4

### [AI-first GTM Playbook](https://seattle.aitinkerers.org/talks/rsvp_mSfnWcYb68k)

The singularity is now defined as human attention—distribution is more important than ever. Over the past 6 months we've been working with startups on developing unique plays for them and their business—but there is commonality in their unique patterns. So what might you experiment with? We've Open Sourced an ideation asset -- called the Tarka GTM Playbook. After spending over 100M tokens in analyzing our last 6 months of logs, we're releasing our first structured canonical playbook—for free. Browse the website as a user or agent (MCP) or browser agent (WebMCP enabled) with helpful search tools to build your unique plan and get guided instructions to build the right plays—available today.

- Event context: AI Tinkerers Seattle: GTM Engineering Kickoff — Building AI for Growth — 2026-02-26 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_mSfnWcYb68k

### [Context Forge - Gaining Control of the MCP Revolution](https://montreal.aitinkerers.org/talks/rsvp__AuvZR5o94g)

Model Context Protocol (MCP) promises a unified, standards-based way for AI models to securely access tools, data, and context across platforms so they can deliver richer, more accurate, and more actionable results. Today, organizations are struggling with inconsistent tool implementations, immature ecosystem support, and integration friction that makes MCP deployments more complex and less reliable than intended. An MCP gateway & registry serves as a central management point for tools, resources, and prompts that can be accessed by MCP-compatible LLM applications. We will demonstrate IBM’s open source MPC-Context- Forge project; how it works and what’s the value for participants.

- Event context: AI Tinkerers Montreal - February 2026 Meetup — 2026-02-24 — Montreal
- Public talk page: https://montreal.aitinkerers.org/talks/rsvp__AuvZR5o94g

### [Operationalising FINOS AI Governance Framework](https://milan.aitinkerers.org/talks/rsvp_acRlcXIQeq0)

In this session, Luca Borella demonstrates how to bridge the gap between abstract AI policy and production-ready implementation. He explores how the FINOS AI Governance Framework (AIGF) serves as the "vertical spine" of the financial tech stack, integrating with emerging standards like MCP and orchestration engines like Fluxnova.

- Event context: AI Tinkerers Milan - February 24, 2026 - Agentic Orchestration in Financial Services: Architectures & Demos — 2026-02-24 — Milan
- Public talk page: https://milan.aitinkerers.org/talks/rsvp_acRlcXIQeq0

### [Inside Claude Code's Brain: Debugging Claude's Behavior with Log Analysis](https://tokyo.aitinkerers.org/talks/rsvp_V2jLkUS8ltU)

Live demo of cclogviewer — an open-source MCP server and CLI tool that reads Claude Code's internal JSONL session logs and turns them into structured, queryable data: tool usage stats, session timelines, token counts, and error summaries. I'll walk through how it works, how to set it up, and how I used it to analyze 650 automated Claude Code sessions to diagnose why skills only activate ~50% of the time and how to create a logs-based improvement loop for Claude Code Subagents.

- Event context: AI Tinkerers Tokyo - Toranomon Meetup - February 19, 2026 — 2026-02-19 — Tokyo
- Public talk page: https://tokyo.aitinkerers.org/talks/rsvp_V2jLkUS8ltU

### [Skwad: multi agent IDE](https://chicago.aitinkerers.org/talks/rsvp_wCMG7hFHLOc)

I built Skwad primarily to support my coding workflow. Multi-tasking with several agents was becoming more and more tedious, juggling between multiple terminal windows and having to manually coordinate work among those agents. Skwad solves both problems by hosting multiple coding agents in a unified app plus allowing those agents to directly communicate through an embedded MCP server. Skwad continues to support my ever changing workflow with new features such as markdown review, mermaid preview and recently a command center providing an overview of all your agents on one single pane of glass.

- Event context: AI Tinkerers Chicago: February Meetup ft. DubClub — 2026-02-17 — Chicago
- Public talk page: https://chicago.aitinkerers.org/talks/rsvp_wCMG7hFHLOc

### [Building an Autonomous Treasury Agent with OpenClaw + MCP (Draft-Only Multisig AI)](https://nyc.aitinkerers.org/talks/rsvp_Sbx7GfUjomM)

In this demo, I’ll show how I transformed a stablecoin-based treasury system into an AI-operable financial agent using OpenClaw and MCP (Model Context Protocol). Instead of dashboards and manual workflows, an OpenClaw agent: Checks USDC balances Analyzes transaction history Generates cash flow reports Drafts multisig payment proposals Monitors KYC status Runs heartbeat-based treasury oversight I’ll walk through: How I designed an MCP skill for financial operations How OpenClaw loads and executes structured tools How I enforced guardrails so AI can draft payments but never execute them How multisig Safe accounts integrate with AI-generated proposals How autonomous monitoring runs via heartbeat routines

- Event context: 🦞Demo Night: OpenClaw ft Convex — 2026-02-17 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_Sbx7GfUjomM

### [Collaborator: Lobster-powered critical thinkig partner](https://nyc.aitinkerers.org/talks/rsvp_Lh8ujzeqlDQ)

Collaborator is a set of open-source tools that turn an OpenClaw agent into a thinking partner. Code walkthrough and live demo of three building blocks: (1) Seedvault — markdown sync between humans and agents, giving the agent a living knowledge base. (2) Reflection pipelines — chained sub-agents that run during OpenClaw's heartbeat, digesting notes into goals, blockers, and recommendations. (3) Collab MCP — a TypeScript server that packages the agent's persona and accumulated knowledge into a portable identity, invokable inside Claude Code or Codex.

- Event context: 🦞Demo Night: OpenClaw ft Convex — 2026-02-17 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_Lh8ujzeqlDQ

### [Give Your Agent Keys, Not the Kingdom](https://singapore.aitinkerers.org/talks/rsvp_kNnv3KNH8yA)

A live demo of Smithery Connect — a managed service that handles the messy parts of connecting AI agents to tools (OAuth flows, credential storage, token refresh) so you don’t have to. I’ll show how to set up a connection to an MCP server in seconds without configuring redirect URIs or client secrets, then do a deep dive into token scoping: creating short-lived, fine-grained tokens that let you safely expose tool access to browsers, mobile apps, and AI agents. We'll explore the idea of Biscuit tokens and attenuation — tokens can only be narrowed, never widened — so you can hand a scoped token to untrusted code and know it can’t escalate its own permissions.

- Event context: AI Tinkerers - The Age of AI & Infrastructure (Singapore) — 2026-02-11 — Singapore
- Public talk page: https://singapore.aitinkerers.org/talks/rsvp_kNnv3KNH8yA

### [Development automation with Claude Code](https://seattle.aitinkerers.org/talks/rsvp_hcHs0cIwhQE)

This will probably continue evolving - this is my current Claude Code setup & it allows me to function as a supervisor as my AI Agent crunches through and verifies large parts of the codebase itself - also includes a bunch of helpful functionality baked in Some things it does well: * Spec-driven development - automated checks to ensure document to doc consistency * Enforces TDD and automated verification * Automated git-based workflow * Stuck detection for agents in loops * Support features and greenfield

- Event context: AI Tinkerers Seattle Meetup: Dev Tools Track — February 9th, 2026 — 2026-02-10 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_hcHs0cIwhQE

### [Design → Agentic UI Parity: Verifiable Figma/XD → MCP App UIs using constraint manifests + template registries](https://nyc.aitinkerers.org/talks/rsvp_ISg04Sc9n2Q)

We’ll demo a verifiable pipeline that translates Figma/Adobe XD designs into constraints + tokens + responsive rules, generates interactive MCP App UIs, and produces a design parity report (auditable) that proves the shipped UI honors design intent across breakpoints. What we’re building (technical, grounded) A design-to-agentic-UI system with four primitives: Design ingestion (Figma/XD) Extract design tokens (color, type scale, spacing), component semantics (buttons, cards, nav), and layout intent (grid, alignment, density). Convert to a normalized Design Intent Spec (DIS). Template registry (universal UI templates) A library of parametric templates (layout archetypes + interaction patterns). Templates accept tokens + constraints and output UI code. Constraint manifest (the verification core) A machine-readable manifest that encodes: Layout constraints (grid columns, min/max widths, padding rules, alignment invariants) Responsive rules (breakpoints, reflow behavior, truncation rules, priority ordering) Component contracts (required states, accessibility expectations, interaction affordances) This manifest is the “source of truth” the generator must satisfy. MCP App UI runtime The UI is delivered as an MCP App (interactive UI inside the client) with explicit tool bindings (UI actions → tool calls). The same manifest drives both generation and verification. The verification mechanism (non-brittle parity checks) We’ll show two complementary verification layers that go beyond “apply tokens”: A) Structural / rule-based verification (fast, deterministic) Compile DIS → constraint assertions per breakpoint: e.g., “card grid is 1-col under 640px, 2-col under 1024px, 3-col above” “primary CTA remains above the fold on mobile” “nav collapses into drawer with N max items visible” Verify the generated UI against these assertions by analyzing: template parameters used layout tree structure computed layout properties for each breakpoint (from the rendered DOM snapshot) B) Visual / perceptual verification (tolerant, non-brittle) Render both: design reference (from Figma/XD export frames) generated UI (MCP App UI at the same viewport sizes) Compute similarity using: a perceptual diff (SSIM/LPIPS-style) and bounding-box alignment checks for key components (header, CTA, cards) Output a parity score per breakpoint + annotated diffs. The auditable output (what we’ll “pop the hood” on) A concrete engineering artifact called a Design Parity Report, containing: tokens applied (hashes + versions) template IDs and parameters used constraint manifest version parity scores per breakpoint annotated diffs for any violations remediation hints (“use Template X instead of Y”, “tighten padding constraint at md breakpoint”) This report is logged as an append-only, auditable event alongside the UI artifact, so teams can prove what changed, why it changed, and whether parity improved or regressed over time. What we’ll demo live (5 minutes) Start with a Figma/XD screen (desktop + mobile frames). Ingest → generate interactive MCP App UI. Run the parity checker across 3 breakpoints. Show the Design Parity Report + one intentional failure (e.g., CTA drops below fold on mobile). Fix by changing a constraint or swapping template → re-run → parity passes.

- Event context: Feb Demo Day: How are you turning design into code? (with Baz) — 2026-02-04 — New York City
- Public talk page: https://nyc.aitinkerers.org/talks/rsvp_ISg04Sc9n2Q

### [Agent mail system as a replacement for software engineering talent](https://st-louis.aitinkerers.org/talks/rsvp_jfOTexBJhv4)

I'll "show the code" of how I use the MCP Agent Mail system to monitor my wildlife detection computer vision continuous retraining loop. The DeerAITrackingResponse project is too broad to cover, so the presentation will focus on how learning to use headless agents and MCP Agent Mail helped me ensure the quality and continuous operation of my sprawling computer vision project. By creating three agents - "Night Watchman", "Day Watchman", and "Model Training Master" and monitoring their communications in the project mail inbox I was able to lean more on my middle management muscles instead of my very weak software engineering muscles. I will introduce the MCP, https://github.com/Dicklesworthstone/mcp_agent_mail, and walk through the prompt that gives Night Watchman his 6 tasks to do during his nightly patrol.

- Event context: AI Tinkerers – St. Louis Meetup: February 4, 2026 — 2026-02-04 — St. Louis
- Public talk page: https://st-louis.aitinkerers.org/talks/rsvp_jfOTexBJhv4

### [Calling Tools like code programmatically](https://seattle.aitinkerers.org/talks/rsvp_Mmbrn3sy9nc)

Codecall changes how agents interact with tools by letting them write and execute code (in deno sandboxes) that orchestrates multiple tools programmatically (like an API) to do a task, rather than making individual tool calls that bloat the context and increase the token usage like in traditional agents

- Event context: AI Tinkerers Seattle: January Meetup — 2026-01-31 — Seattle
- Public talk page: https://seattle.aitinkerers.org/talks/rsvp_Mmbrn3sy9nc

### [How We Built an AI-Native Business Factory Anyone Can Run From Their Phone. From Phone to Empire in Hours, Not Years! English Is the New Interface.](https://san-diego.aitinkerers.org/talks/rsvp_GvNDHEXsW_s)

In 2026 the bottleneck isn’t coding—it’s execution. This talk shows how we built NetShow IQ1, an AI-native business factory designed for real operators: the small business owner who barely does email, the busy parent, the non-technical founder with a clear idea. I’ll walk through how a plain-English idea becomes a complete business stack in one orchestrated run—validated offer, branded web presence, working product/service flow, marketing assets, and operational agents for sales/support/admin—plus the practical engineering discoveries that made it reliable: agent handoffs, “agents test agents” quality gates, and cost/safety controls so normal people can run it without becoming technical.

- Event context: AI Tinkerers San Diego: January Meetup — 2026-01-23 — San Diego
- Public talk page: https://san-diego.aitinkerers.org/talks/rsvp_GvNDHEXsW_s

### [Intercepting AI Tool Calls: Preventing Hallucinated IDs with LangGraph MCP Middleware](https://cologne.aitinkerers.org/talks/rsvp_0aDoOqEb6qA)

Live walkthrough of a production middleware pattern that intercepts LLM tool calls before execution to inject correct workflow IDs, preventing hallucinated values. The demo covers: The problem: LLMs hallucinate workflow IDs when calling n8n tools via MCP The solution: WorkflowInjectorToolNode wrapping LangGraph's ToolNode to intercept and modify tool calls Implementation details: how to modify AIMessage.tool_calls before execution, handle edge cases, and maintain compatibility with LangGraph's tool matching Trade-offs: when to use middleware vs. prompt engineering vs. tool design Includes real code from a production agent system, showing the interception logic, error handling, and integration with LangGraph's checkpointing system.

- Event context: AI Tinkerers Cologne #2: Let's Build. — 2026-01-21 — Cologne
- Public talk page: https://cologne.aitinkerers.org/talks/rsvp_0aDoOqEb6qA

## Related Technologies

- [Claude Code](https://aitinkerers.org/technologies/claude-code) ([Markdown](https://aitinkerers.org/technologies/claude-code.md)) — 215 public demos
- [TypeScript](https://aitinkerers.org/technologies/typescript) ([Markdown](https://aitinkerers.org/technologies/typescript.md)) — 205 public demos
- [Python](https://aitinkerers.org/technologies/python) ([Markdown](https://aitinkerers.org/technologies/python.md)) — 662 public demos
- [Claude](https://aitinkerers.org/technologies/claude) ([Markdown](https://aitinkerers.org/technologies/claude.md)) — 174 public demos
- [OpenAI API](https://aitinkerers.org/technologies/openai-api) ([Markdown](https://aitinkerers.org/technologies/openai-api.md)) — 520 public demos
- [Gemini](https://aitinkerers.org/technologies/gemini) ([Markdown](https://aitinkerers.org/technologies/gemini.md)) — 188 public demos
- [Docker](https://aitinkerers.org/technologies/docker) ([Markdown](https://aitinkerers.org/technologies/docker.md)) — 147 public demos
- [LangChain](https://aitinkerers.org/technologies/langchain) ([Markdown](https://aitinkerers.org/technologies/langchain.md)) — 445 public demos
- [Node](https://aitinkerers.org/technologies/node) ([Markdown](https://aitinkerers.org/technologies/node.md)) — 99 public demos
- [Playwright](https://aitinkerers.org/technologies/playwright) ([Markdown](https://aitinkerers.org/technologies/playwright.md)) — 32 public demos
- [GitHub](https://aitinkerers.org/technologies/github) ([Markdown](https://aitinkerers.org/technologies/github.md)) — 74 public demos
- [LLM](https://aitinkerers.org/technologies/llm) ([Markdown](https://aitinkerers.org/technologies/llm.md)) — 123 public demos
- [Cursor](https://aitinkerers.org/technologies/cursor) ([Markdown](https://aitinkerers.org/technologies/cursor.md)) — 65 public demos
- [Next](https://aitinkerers.org/technologies/next) ([Markdown](https://aitinkerers.org/technologies/next.md)) — 186 public demos
- [GitHub Actions](https://aitinkerers.org/technologies/github-actions) ([Markdown](https://aitinkerers.org/technologies/github-actions.md)) — 20 public demos
- [HTTP](https://aitinkerers.org/technologies/http) ([Markdown](https://aitinkerers.org/technologies/http.md)) — 14 public demos
- [OpenAI](https://aitinkerers.org/technologies/openai) ([Markdown](https://aitinkerers.org/technologies/openai.md)) — 112 public demos
- [PostgreSQL](https://aitinkerers.org/technologies/postgresql) ([Markdown](https://aitinkerers.org/technologies/postgresql.md)) — 106 public demos

## More Results

- Previous: https://aitinkerers.org/technologies/mcp.md?page=2
- Next: https://aitinkerers.org/technologies/mcp.md?page=4