标签：#mcp

You asked Claude Code to add a query for orders by customer status. It generated a .scan() with a FilterExpression . Your Orders table has 50M rows and three functions already hammering the same partition key. Claude Code had no idea — it read your TypeScript files, not your AWS account. That's the problem. AI coding assistants are literate in your source code. They are blind to your infrastructure. GitHub · npm What Claude Code Actually Sees (and What It Doesn't) When Claude Code reads your codebase, it builds a model of your application: function names, variable patterns, the string "Orders" passed to DynamoDB.DocumentClient . It can follow call chains, infer intent, and generate syntactically correct code. What it cannot do is describe your actual infrastructure: It doesn't know which GSIs exist on your DynamoDB tables It doesn't know how your tables are partitioned or what sort keys you use It doesn't know that listAllOrders() already does a full scan and costs $40/day It doesn't know that 5 functions already write to the same partition key on Sessions So when you ask it to add a new query, it generates something that looks correct. It might use .query() instead of .scan() . But it'll query on an attribute with no index — because it has no way to know which attributes are indexed. It'll write a FilterExpression that reads every item before filtering — which is exactly a scan, just spelled differently. The code compiles. Tests pass. The problem ships. The Three Commands That Close the Gap infrawise gives Claude Code deterministic knowledge of your infrastructure through the Model Context Protocol. Three commands get you there. 1. infrawise init cd your-project infrawise init Runs once per project. Detects your AWS profile and region, asks which databases you use, and writes a single file: infrawise.yaml . That's the only file it creates in your repository — one config, no framework, no SDK changes. 2. infrawise doctor infrawise doctor Before you trust any analysi

This week, the first offline-first PWA went live on WebsitePublisher.ai . A travel blog that works without internet. Write posts on a plane, attach photos, and everything syncs the moment you reconnect. Service Worker, IndexedDB, sync queue — the full stack. The twist: it was built entirely through conversation with an AI assistant. No IDE, no terminal, no deploy pipeline. How that works WebsitePublisher.ai exposes 92 integrations as building blocks via MCP (Model Context Protocol). Any AI assistant — ChatGPT, Claude, Cursor, Windsurf, Copilot, Gemini, Grok, Mistral — connects to the same runtime and assembles these blocks into working applications. The offline-first PWA is one of those blocks. The AI doesn't generate a Service Worker from scratch. It activates a proven, tested building block and configures it for the use case. We call this wave coding — one deliberate wave of proven pieces, instead of 15 fragile vibe-coding attempts. What shipped recently Offline-first PWA building block — push/pull sync, conflict handling, IndexedDB storage, works on iOS 92 integrations (up from 78) — 45 built-in, 47 bring-your-own-key Integration stacks — pre-composed combinations: e-commerce (13 integrations), lead generation, B2B prospecting, booking, content/blog 9 AI platforms supported — all via MCP, no vendor lock-in 416 API endpoints across the platform ## The architecture in short AI assistant (any) → MCP → WebsitePublisher runtime ├── PAPI (pages + assets) ├── MAPI (structured data) ├── SAPI (forms + auth + sessions) ├── IAPI (integration proxy) ├── VAPI (encrypted vault) └── AAPI (scheduled AI agents) Credentials never touch the AI. They're stored AES-256-GCM encrypted in the vault and injected server-side during execution. The positioning We're not competing with Lovable or Bolt on the chat interface. We're the Supabase + Vercel + n8n underneath — reachable via whichever AI you already use. The platform your AI builds on. websitepublisher.ai

Sylwia Laskowska's webMCP article is clever, funny, and genuinely enjoyable—and she's explicit that it's experimental, not a production recommendation. This isn't a rebuttal. It's a reframing: the same demo, viewed through the lens of risk surfaces and governance. My concern isn't with her intent — it's with how easily newcomers building client systems may misread a playful demo as a pattern to copy. I. The Demo Was Funny Because the Risk Is Real In Sylwia's article, she writes: webMCP allows websites to expose structured information about available actions… Those "actions" aren't descriptive hints. They are callable functions wired directly into application logic. In her demo, those actions include: hire_employee fire_employee rewriteInRust pivotToAgents It's hilarious in a toy app. It's catastrophic in a real one. The humor works precisely because the underlying risk is real. II. The Hidden Assumption: Exposing Actions Is Neutral webMCP is framed as "like accessibility metadata." But accessibility metadata is descriptive. webMCP metadata is executable. That's the conceptual inversion most newcomers will miss. III. Structural Vulnerability #1: Unbounded Action Surface If a tool exists, an agent can call it. There is no: permission model capability scoping rate limiting intent validation safety envelope Sylwia jokes: "someone will definitely give an agent access to fireEmployee(), the agent will lay off the entire company…" This is not a hypothetical. It is the exact failure mode. IV. Structural Vulnerability #2: Agent Overreach Her CEO sim demonstrates the problem perfectly: the agent selected the appropriate tools and immediately got to work. Agents act with high confidence even when their world model is incomplete. webMCP gives them direct levers into application state. This is the same overreach problem MCP has—just moved into the browser. V. Structural Vulnerability #3: Protocol Brittleness webMCP relies on human-authored descriptions: html<form mcp-name="creat

I Built a Python Package to Fix SSE Resumability in the MCP SDK Your MCP server crashed. Your client reconnected. Every event from that session? Gone. The Gap The Model Context Protocol Python SDK ships with a built-in EventStore that powers SSE stream resumability — when a client reconnects with a Last-Event-ID header, the server replays the events it missed. This works great in development. The catch: that store lives entirely in memory. Restart the process, roll a new deployment, or — in a multi-worker setup — have the reconnecting client land on a different pod, and the session is gone. The store was local to the process that died. Resumability silently returns nothing. This isn't a bug in the SDK. It's a scope decision — the in-memory store is a correct, useful default for single-process development. But the moment you deploy to production, you need something durable. That's the gap mcp-persist fills. What It Does mcp-persist adds three drop-in EventStore backends — SQLite , Redis , and PostgreSQL — that survive process restarts and work across multi-worker deployments. Pick the one that fits your infrastructure; the API is identical across all three. pip install "mcp-persist[sqlite]" # no external service needed pip install "mcp-persist[redis]" # for multi-worker deployments pip install "mcp-persist[postgres]" # for teams already running Postgres The Two-Line Setup Wiring resumability by hand is tedious — you need a store, a StreamableHTTPSessionManager , a Starlette lifespan to open and close both, and a Mount . The with_persistence() helper collapses all of that. Pass your FastMCP instance, get back a runnable ASGI app: import uvicorn from mcp.server.fastmcp import FastMCP from mcp_persist import with_persistence mcp = FastMCP ( name = " MyServer " ) app = with_persistence ( mcp , backend = " sqlite " , url = " events.db " , ttl = 3600 ) uvicorn . run ( app , host = " 127.0.0.1 " , port = 8000 ) # MCP endpoint at /mcp Switching to Redis is a one-word change:

Every AI agent ships with the same bottleneck: it can only reason over what it can reach. MCP servers dissolve that boundary. They expose tools, resources, and prompts to any compliant client over a JSON-RPC wire format so lean you can implement it in an afternoon. Yet most developers grab a framework, copy a template, and ship something they can barely debug. Forge starts differently. You will build an MCP server from the bare protocol up, understand every byte on the wire, and gain the mental model that makes every future server trivial. The Idea (60 Seconds) MCP is a JSON-RPC 2.0 protocol. A client sends a request. Your server returns a response. Three request types power the core loop: initialize , handshake. Client and server exchange capabilities. tools/list , discovery. Server returns every tool it offers, each with a JSON Schema describing its inputs. tools/call , execution. Client names a tool and passes arguments. Server runs the handler and returns structured content. Transport is either stdio (JSON-RPC over stdin/stdout) or HTTP (Streamable HTTP). Stdio is the simplest place to start: read a line from stdin, parse it, dispatch, write a line to stdout. That is the entire architecture. Everything else is error handling, schema validation, and ergonomics. Why This Matters MCP servers are the new APIs. Where REST gave machines endpoints, MCP gives agents tools with typed inputs and structured outputs. Every integration layer from IDE assistants to autonomous workflows converges on this protocol. The standard is young. The primitives are stable. The surface area is small enough to hold in your head all at once. Knowing the wire format gives you three advantages frameworks obscure: Debugging , when a tool call fails, you can read the raw JSON-RPC message and pinpoint the fault in seconds. Portability , any language, any runtime, any transport. Write a server in Bash if you want. The protocol is the contract. Evolution , MCP will add capabilities. Understanding

It all started in a plaza. One guy with apples, another with wheat. They looked at each other, negotiated, and traded. That's how commerce worked for thousands of years: face to face, hand to hand, trust to trust. If you wanted to buy something, you had to go where it was. If you wanted to sell, you had to wait for someone to show up. Commerce had a physical limit: your body. You couldn't be in two places at the same time. Your market was your street, your town, your city. Nothing more. Then internet came along and someone asked: what if the store doesn't need walls? E-commerce eliminated distance. Amazon started selling books from a garage. MercadoLibre connected a seller in Santiago with a buyer in Antofagasta. Shopify gave an online store to anyone with a credit card. Suddenly, an artisan in southern Chile could sell to the entire country. An entrepreneur in Colombia could have clients in Mexico. The market stopped being a street and became the planet. But e-commerce had a problem nobody wanted to see: it still needed a human behind it. Someone had to update the inventory. Someone had to answer the questions. Someone had to make the quotes, check the payments, control the stock, send the shipments, analyze the metrics, decide the prices. E-commerce digitized the storefront, but it didn't digitize the operation. And that's where we are now. MCP-Commerce is not a term that exists yet. I'm inventing it because I need a name for what's coming. MCP — Model Context Protocol — is a protocol that lets AI use tools. Not "display" tools. Use them. Read a database, send an email, create an invoice, update an inventory, analyze this month's sales. In traditional commerce, you were the store. In e-commerce, you had an online store. In MCP-commerce, the AI IS your operation. It's not a chatbot that answers questions. It's a system that manages your entire business through conversation. You say "how much did I sell this week" and it responds with real data. You say "I need to c

Syndicated from the FavCRM blog . The old quote was two weeks. With an agent on the UI and a headless backend, it's an afternoon. A client needs a booking site. The old quote was two weeks: a calendar, a database, an availability engine, payments, a customer table. With an AI agent building the frontend and FavCRM as the headless backend , the real work is an afternoon. Here is the whole job, start to finish. The scenario A small clinic. Three services, one practitioner, online booking with deposit. You are the agency; you have an AI agent in your editor and a terminal. The plan: Register the clinic's FavCRM workspace Configure services and availability Wire one server route that talks to FavCRM Let the agent build the booking UI against that route Test a real booking end to end Step 1 — Register the workspace (~5 min) The favcrm CLI registers a workspace and issues an API key. No dashboard. favcrm signup request --email clinic@example.com \ --organisation-name "Bright Smile Clinic" favcrm signup verify --request-id < id > --code <6-digit-code> The verify step prints a fav_mcp_* key. Put it where your build can read it — never in the repo: export FAVCRM_API_KEY = fav_mcp_... Step 2 — Configure services and availability (~30 min) Hand the brief to your agent and let it call the tools. Inspect a schema first: favcrm tool describe create_service Then create each service: favcrm tool call create_service '{ "name": "New Patient Exam", "durationMinutes": 45, "price": "80.00" }' favcrm tool call create_service '{ "name": "Cleaning", "durationMinutes": 30, "price": "60.00" }' Set when the practitioner works, so availability is real: favcrm tool call set_staff_availability '{ "weekday": "mon", "start": "09:00", "end": "17:00" }' Repeat per weekday. At this point the backend is done — services, hours, an availability engine that knows about clashes. You wrote no schema. Step 3 — One server route (~30 min) The browser must never hold the API key. Put it in one server route tha

Syndicated from the FavCRM blog . The number that predicts whether an agent is safe to let loose isn't the tool count. When people compare agentic CRMs, they count tools. The number that actually predicts whether an agent is safe to let loose is a different one: annotation coverage . An MCP tool annotation tells the agent what a tool does to the world — whether it reads or mutates, whether it's safe to retry, whether it reaches an external service. Without annotations, the agent is guessing. This is what they are, and why a catalog's annotation coverage matters more than its tool count. What an MCP annotation is Every MCP tool can carry hints alongside its input and output schemas: readOnlyHint — the tool only reads; it changes nothing. Safe to call freely. destructiveHint — the tool mutates or deletes. The agent should confirm before calling. idempotentHint — calling it twice with the same input has the same effect as once. Safe to retry on a timeout. openWorldHint — the tool reaches an external service (sends an email, charges a card), so its effects leave the system. These are not documentation for humans. They are machine-readable signals the agent reasons over before it acts. Why they prevent the worst failures The dangerous class of agent failure is not "the agent couldn't do something." It's "the agent did the wrong destructive thing because it misread an ambiguous instruction." Delete the customer instead of the tag. Refund the wrong invoice. Cancel every booking instead of one. Annotations let the agent self-gate. A well-annotated catalog means the agent calls list_members without ceremony but pauses to confirm before cancel_booking , because one is marked read-only and the other destructive. Pre-MCP function-calling had no equivalent — every tool looked the same to the model, so safety lived entirely in the prompt. Why coverage matters more than count A 190+ tool catalog with 100% annotation coverage is safer than a 30-tool catalog with none. A tool that l

Building a Benchmarking Agent with A2A and MCP This tutorial aims to build and test benchmarking Agents using the A2A protocol across several mainstream Cloud providers. A Master Orchestrator Agent is exposed via MCP to allow Antigravity CLI to be used as a MCP client to co-ordinate the benchmarks. Deja Vu — What is Old is New! This paper is a re-visiting of the original benchmark series with Gemini CLI over Node, GO, and Python: Cross Language A2A Agent Benchmarking with Gemini 3 and Gemini CLI In this updated version, the Antigravity CLI is used to push Rust Agents cross-cloud and co-ordinate Mersenne Prime Calculations. Why would I need Multi-Cloud Support? And Rust? Can’t I just use Python? Most mature Agent development tools and libraries are Python based. Python allows for rapid prototyping and evaluation of approaches. Python is also an interpreted language- which has trade-offs in memory safety, and performance. Other languages like GO and Rust offer high performance and memory safe operations. With a language neutral communication protocol — the actual Agent implementation of each Agent can be coded in the most appropriate language. What is this Approach actually Benchmarking? The high level goal was to measure the actual time spent running an algorithm in the native language code inside the A2A agent. Each language had a slightly different implementation due to the language syntax. After running the algorithm- each Agent was instructed to calculate and return the elapsed time for cross cloud comparison. What is the A2A protocol? The Agent2Agent (A2A) protocol, an open communication standard for AI agents, was initially introduced by Google in April 2025. It is specifically engineered to facilitate seamless interoperability within multi-agent systems, enabling AI agents developed by diverse providers or built upon disparate AI agent frameworks to communicate and collaborate effectively. A good overview of the A2A protocol can be found here: A2A Protocol Lan

The Setup I've been building AI agents that use tools — reading files, running commands, calling APIs. There are two main ways to give agents these tools: MCP (Model Context Protocol) — the new standard everyone's adopting Direct CLI calls — good old command-line execution Everyone says MCP is the future. But nobody talks about the token cost . So I measured it. The Test I built a simple file-reading tool and measured the exact token consumption for each approach: Method Tokens per Call Latency (avg) MCP (structured) ~3,400 tokens 280ms CLI + raw output ~200 tokens 45ms Ratio 17x 6x Why MCP Uses So Many Tokens The overhead comes from three places: 1. Tool Schema in Every Request MCP sends the full JSON Schema of every available tool with each request to the LLM. My simple file-reader schema alone is ~800 tokens. With 10+ tools, that's 8,000+ tokens of schema on every single call. { "name" : "read_file" , "description" : "Read contents of a file at given path" , "parameters" : { "type" : "object" , "properties" : { "path" : { "type" : "string" , "description" : "File path to read" } }, "required" : [ "path" ] } } 2. Structured Response Wrapping MCP wraps every response in a structured envelope with metadata, status codes, and typed content blocks. A simple "file not found" error becomes a 200-token JSON object. 3. Round-Trip Protocol Overhead Each MCP call involves: request → server parse → execute → format response → return → client parse → extract. Each step adds tokens for protocol framing. The CLI Alternative With direct CLI execution: $ cat /path/to/file.txt [ raw file content] That's it. Raw input, raw output. No schemas, no envelopes, no metadata. When MCP Is Worth It Despite the token cost, MCP shines when: You need standardized discovery — agents dynamically finding available tools You're building reusable tool servers — one MCP server serves many agents Security sandboxing matters — MCP's permission model is more granular Team collaboration — shared tool de

A few years ago, we started adapting our websites for mobile devices. Then we adapted them for...

This is a submission for the GitHub Finish-Up-A-Thon Challenge The Project That Got Away Three months ago, I started building something I was genuinely excited about: devto-mcp — a Model Context Protocol (MCP) server that would let AI agents interact with Dev.to's API natively. No more cobbling together curl commands. No more writing custom wrapper scripts for every AI tool. Just a clean, standards-compliant MCP server that any AI agent could plug into. I had a vision: an AI agent that could autonomously research trending topics, draft articles, publish them, track engagement, and iterate — all through a single protocol. The kind of thing that sounds simple until you actually sit down to build it. I got about 40% of the way through. Then life happened. A client project deadline. A cross-country move. A laptop that decided to corrupt its SSD at the worst possible time. The repo sat there on GitHub, collecting digital dust, with half-implemented tool functions and a README that promised way more than the code delivered. Sound familiar? If you've been a developer for more than a year, you have at least one of these ghost repos. That ambitious side project you were so sure you'd finish "next weekend." The one with the clever name and the detailed architecture doc but barely functional code. Two weeks ago, I saw the GitHub Finish-Up-A-Thon announcement. I looked at my list of abandoned repos. And I thought: it's time. What I Built: devto-mcp devto-mcp is a Model Context Protocol server that exposes Dev.to's entire API as MCP-compatible tools. If you're not familiar with MCP, it's the protocol that lets AI assistants like Claude, Cursor, and other coding agents interact with external tools in a standardized way. Think of it as a universal adapter between AI models and the services developers actually use. Here's the problem it solves: Every time you want an AI agent to interact with Dev.to — whether it's searching for articles, publishing a post, checking analytics, or ma

If you write code for Adobe Commerce or Magento 2, you spend a lot of time waiting. Build times are slow, static content deployment takes forever, but the real time sink is documentation. The EAV architecture, nested XML layouts, and ever-changing GraphQL mutations mean you are constantly Alt-Tabbing to a browser to double check a syntax pattern. Every time you leave your IDE to search the Experience League portal, you lose your train of thought. You copy error codes, dig through unrelated search results, and try to find a working code snippet. It is exhausting. I wanted my coding assistant to just know this stuff without making me look it up. That is why I configured this MCP server. The adobe-commerce-docs-mcp package connects your IDE directly to the official Adobe documentation. It works with Cursor, Claude Desktop, VS Code, and Windsurf, pulling raw markdown docs right into your chat context. The architecture: bridging AI and docs Instead of relying on web search or stale training data, the server queries the live Adobe Experience League site. It indexes the content locally, caches pages, and handles queries via the MCP protocol. 1. BM25 search ranking The server parses the official Adobe sitemap and ranks pages using BM25 relevance scoring. This is the same search algorithm databases use to weigh search term frequency against document length. It means your assistant gets the most relevant setup guide first, not just the page that mentions a keyword the most. 2. Synonyms and fuzzy matching You do not have to query exact terminology. The search engine maps Magento specific synonyms: graphql searches also find pages with gql module searches also match extension cloud searches match ece It also corrects simple typos like chekout or catlog to checkout and catalog. 3. Local caching Network requests are slow, so the server uses two layers of caching: An in-memory cache for recent queries. A persistent file cache on your disk. Sitemap data lasts 24 hours, while downlo

Last week I built a little dashboard with Claude. Took maybe ten minutes. Then I spent the next hour trying to get it online. ssh in, install docker, write a Dockerfile, set up nginx, run certbot, certbot fails, read the log, oh the DNS hasn't propagated, wait, run it again, open port 443, realize ufw was blocking it the whole time. By the time it was live I'd forgotten what the app even did. I've done that maybe a few hundred times by now. I'm a backend guy, I'm fast at it. But fast at something boring still means doing the boring thing. So at some point I just thought: the AI already wrote the app. Why does it stop right when the annoying part starts? Why doesn't it just deploy the thing itself? The reason is it has no hands. The model can write you a perfect docker-compose file. It can't ssh into your box and run it. No connection to your server, nowhere to hold your key. So I gave it hands. It's an MCP server, vibe-deploy. You hook it up once to a VPS you own, and then you just say "deploy this to notes.mydomain.com" and the agent containerizes it, ships it over ssh, sets up nginx, gets a real Let's Encrypt cert. Node, Python, Go, plain static. It figures out the stack and writes the Dockerfile. No PaaS, no per-seat pricing, no free tier you'll outgrow. A $5 box runs a dozen of my projects and I own the whole thing. The "you gave an AI root on your server??" reaction is fair, so: it runs locally, your key never leaves your laptop. I used a separate ssh key scoped to deploys, not my real one, and you should too. It checks the server host key before connecting and validates everything you pass it, because a deploy tool that pastes your input straight into a shell is a horror story waiting to happen. I had someone audit the security before I put it out. They found two real bugs. I fixed them. It's free and MIT, on GitHub and npm as @cgnguyen/vibe-deploy . I built it because I wanted it. If you live in the same gap between "it works on localhost" and "it's online",

클로드로 한글파일(HWP) 변환·자동화하는 법 2026 — 요약·표 추출·일괄 처리 실전 한글파일을 Claude로 다루려는 한국 기업 실무자가 가장 먼저 부딪히는 벽은 " 읽기는 됐는데, 그래서 뭘 어떻게 자동화하지? "다. HWP-MCP를 설치해 Claude가 한글 문서를 읽게 만드는 것까지는 HWP-MCP 도입 가이드 에서 다뤘다. 이 글은 그 다음 단계 — 실제 업무에서 한글파일을 요약·변환·일괄 처리하는 구체적 방법 을 실전 예시로 보여준다. 한글파일 AI 자동화의 핵심은 "한컴 오피스 라이선스 없이, 사람 손을 거치지 않고, 반복 작업을 Claude에게 위임하는 것"이다. 계약서 100건 요약, 요구사항서의 표를 CSV로 추출, 폴더 안 HWP 일괄 변환 — 이런 작업이 자동화 대상이다. 한글파일 자동화로 풀 수 있는 업무 3가지 업무 수동 작업 시간 자동화 후 적용 키워드 문서 요약 1건당 10~15분 50건 30초 claude 한글파일 요약 표 → 데이터 추출 1표당 5분 (재입력) 표 자동 CSV 변환 hwp 표 추출 일괄 변환·정리 100건 8시간 100건 1시간 20분 한글파일 일괄 처리 세 업무 모두 "사람이 한글파일을 열어 읽고, 내용을 옮겨 적는" 반복 작업이다. Claude + HWP-MCP 조합은 이 중간 단계를 없앤다. 전제: HWP-MCP 연결 확인 자동화에 들어가기 전, Claude가 한글파일을 읽을 수 있는 상태인지 확인한다. (설치 절차는 HWP-MCP 도입 가이드 참조.) # Claude Desktop 설정에서 hwp-mcp 서버가 연결됐는지 확인 # MCP 도구 목록에 hwp_read, hwp_extract_tables 등이 보여야 함 연결이 확인되면 아래 3가지 워크플로우를 바로 쓸 수 있다. 워크플로우 1: 한글파일 요약 자동화 계약서·보고서·요구사항서처럼 길이가 긴 한글 문서를 Claude에게 요약시키는 패턴이다. 단일 문서: "이 한글파일을 읽고 다음 3가지로 요약해줘: 1. 핵심 내용 5줄 2. 의사결정이 필요한 항목 3. 누락되거나 모호한 조항" 여러 문서 일괄 요약: 폴더 경로를 주고 "이 폴더의 모든 .hwp 파일을 각각 위 형식으로 요약하고, 결과를 하나의 마크다운 표로 정리해줘"라고 지시하면, Claude가 HWP-MCP로 파일을 순회하며 처리한다. 50개 문서 기준 약 30초. 요약 품질을 높이는 팁: "요약 기준"을 구체적으로 명시 할수록 결과가 좋다. "계약 금액·기간·위약 조항 중심으로" 같은 도메인 컨텍스트를 주면 일반 요약보다 실무 적합도가 크게 오른다. 워크플로우 2: 표 → CSV 데이터 추출 한글파일의 표는 복사-붙여넣기로 옮기면 서식이 깨지는 게 가장 큰 골칫거리다. HWP-MCP의 표 추출 기능을 쓰면 구조를 유지한 채 데이터만 뽑는다. "이 한글파일에 있는 모든 표를 추출해서 CSV로 변환해줘. 표가 여러 개면 각각 별도 파일로, 헤더 행을 포함해서." 활용 시나리오: 견적서·정산표 : 한글 견적서의 항목·단가·합계를 회계 시스템에 올릴 CSV로 요구사항 명세 : 기능 목록 표를 이슈 트래커(Jira/Linear) import 형식으로 설문·조사 결과 : 한글 보고서의 통계 표를 분석용 데이터프레임으로 표 안에 병합 셀이 있으면 Claude에게 "병합 셀은 상위 값으로 채워줘(forward fill)"라고 미리 지시하는 게 데이터 정합성에 좋다. 워크플로우 3: 폴더 일괄 처리 가장 ROI가 큰 패턴. 수백 개 한글파일이 쌓인 폴더를 통째로 처리한다. "./contracts 폴더의 모든 .hwp 파일에 대해: 1. 계약 상대방·금액·시작일·종료일을 추출 2. 하나의 CSV로 통합 (파일명을 첫 열에) 3. 종료일이 30일 이내인 계약은 ⚠️ 표시" 100건 기준 수동 8시간 작업이 약 1시간 20분으로 줄어든다(실측). 핵심은 추출 스키마를 먼저 정의 하는 것 — 무엇을 뽑을지 명확할수록 일괄 처리 정확도가 높다. python-docx·한컴 API와 무엇이 다른가 방식 한글파일(.hwp) 지원 자동화 난이도 AI 통합 한컴 오피스 자동화

Claude Code에서 Codex로 옮길 때 — 실전 마이그레이션 가이드 2026 Claude Code 기반 워크플로우를 OpenAI Codex CLI로 옮기려는 팀이 늘고 있다. 모델 가격, 멀티 벤더 리스크 분산, 특정 코딩 워크로드의 성능 차이 등 이유는 다양하다. 그런데 두 도구는 같은 "AI 코딩 에이전트"라는 카테고리에 속해도 컨벤션·확장 메커니즘이 다르다. 무작정 옮기면 자동화 파이프라인의 절반이 깨진다. 이 가이드는 Claude Code → Codex 마이그레이션을 실제로 끝내본 팀이 어떤 순서로 무엇을 옮기고, 무엇을 포기하고, 무엇을 대체했는지 정리한다. 자동 변환 툴( claude2codex )을 어디서 쓰고 어디서 안 쓰는지, 일주일 점검 체크리스트, 양쪽을 분기 사용하는 하이브리드 패턴까지 다룬다. 마이그레이션 전 의사결정 — 옮길지 말지부터 옮기는 게 모두에게 정답은 아니다. 다음 세 질문에 모두 "예"여야 본격 마이그레이션을 권한다. 현재 Claude Code 비용의 60% 이상이 일상적인 코드 편집·리뷰에서 발생하는가? (Codex의 GPT-5-codex가 단가 우위를 보이는 영역) — 만약 디자인·기획·문서 분량이 큰 워크플로우라면 Claude를 유지하는 게 합리적이다. Skills·Hooks·서브에이전트 같은 Claude 고유 기능에 의존하지 않는가? 의존도가 높다면 마이그레이션 비용이 비용 절감을 초과한다. 하나의 벤더 락인을 줄이는 게 중요한 전략적 우선순위인가? 멀티 벤더 운영은 그 자체로 관리 비용이 든다. 세 질문 중 하나라도 "아니오"라면, 통째 마이그레이션 대신 하이브리드 분기 사용 (아래 5절)이 더 낫다. Claude Code와 Codex의 핵심 차이 비교 영역 Claude Code OpenAI Codex CLI 마이그레이션 난이도 메인 모델 claude-opus-4-7 / sonnet-4-6 / haiku-4-5 GPT-5 / GPT-5-codex / o1 계열 낮음 (모델 교체) 컨벤션 파일 CLAUDE.md AGENTS.md (멀티 벤더 표준) 낮음 (rename + 어조 조정) 확장 메커니즘 Skills (markdown SKILL.md + 메타데이터) 별도 표준 없음, 수동 컨텍스트 로딩 높음 (가장 큰 갭) 자동화 훅 Hooks (PreToolUse, SessionStart, UserPromptSubmit 등) 라이프사이클 이벤트 미지원 높음 (외부 wrapper 필요) 슬래시 커맨드 /명령 형태 + 인자 파싱 CLI 인자로 대체 중간 MCP 서버 1급 지원, 자동 도구 노출 일부 지원, 설정 형식 다름 중간 서브에이전트 Agent tool (subagent_type) 외부 오케스트레이션 필요 높음 권한 모드 acceptEdits / plan / dontAsk 등 --auto / --confirm 류 낮음 가장 큰 갭 세 곳: Skills · Hooks · 서브에이전트 . 이 세 가지에 깊이 의존하는 팀은 마이그레이션 ROI가 마이너스로 나올 수 있다. 마이그레이션 절차 — 7단계 1단계: 자산 인벤토리 (1일) .claude/ 디렉토리, CLAUDE.md , 프로젝트 루트의 slash command 정의, hook 설정, MCP 서버 목록을 전부 추출한다. find . -path "*/.claude/*" -type f > migration/inventory.txt ls .claude/skills/ .claude/hooks/ .claude/commands/ 2>/dev/null >> migration/inventory.txt cat .claude/settings.json | jq '.mcpServers // {}' > migration/mcp.json 이 파일들이 모두 변환되거나, 대체되거나, 폐기되는지 명시적으로 매핑되어야 한다. "그냥 옮기면 되겠지"는 거의 항상 일주일 후 장애로 돌아온다. 2단계: claude2codex 자동 변환 적용 (반나절) 오픈소스 claude2codex 마이그레이션 툴 이 자동으로 처리하는 것: CLAUDE.md → AGE

Most scraper demos lie by accident. They show the happy path: one URL, one clean page, one neat JSON object. Then the first real user tries a marketplace search page, a login wall, a JavaScript shell, a rate-limited product page, or a site that serves different HTML to every fetch path. The response still comes back as JSON, so everyone relaxes. That is the trap. A JSON response is not the same thing as a useful extraction. The failure mode agents hate AI agents do not just need scraped text. They need to know what happened. Bad extraction output looks like this: { "title" : "Example product" , "price" : "$29.99" , "availability" : "in stock" } That looks fine until you inspect the source and discover the page was a login prompt, a bot challenge, or a thin JavaScript shell. The extractor filled the schema because the schema was requested. Helpful. Like a smoke alarm that hums a little song while the kitchen burns. Better extraction output separates the data from the confidence and the failure class: { "status" : "failed" , "failure_type" : "login_required" , "confidence" : 0.94 , "extracted" : null , "evidence" : { "final_url_type" : "restricted_page" , "visible_content" : "login prompt" , "structured_data_found" : false }, "next_step" : "Use an authorised source, public item URL, feed, API, or sample HTML." } That is less flashy. It is also much more useful. The useful contract is not “scrape anything” “Scrape anything” is usually a warning label wearing lipstick. For agent workflows, the better contract is: Return structured data when the page provides enough evidence. Return a specific honest failure when it does not. Preserve enough metadata for the caller to decide what to do next. Never invent fields just because a prompt asked nicely. This matters for ecommerce, lead enrichment, price monitoring, competitor tracking, procurement, and internal research agents. If the agent cannot tell the difference between “product unavailable”, “page blocked”, “login require

If you run a website that serves European users — or if you’re based in the EU yourself — hosting location is no longer just a technical detail. It has become a strategic and legal consideration. In 2026, questions around data residency, GDPR compliance, and digital sovereignty are front and center for businesses of all sizes. Choosing where your website and its data live can affect everything from legal risk to user trust and even search engine performance. The core issue: Where does your data actually live? When you choose a hosting provider or CMS, your content, user data, images, and analytics often get stored on servers in a specific country or region. This matters because different jurisdictions have different laws regarding data access, privacy, and government requests. Key concerns include: GDPR compliance : The EU’s strict data protection regulation requires that personal data of EU citizens be handled with strong safeguards. Transferring data outside the EU/EEA can trigger additional legal requirements (such as Standard Contractual Clauses). Schrems II and data transfers : Following court rulings, simply relying on old mechanisms for transferring data to the US became more complicated. Many organizations now prefer to keep data within the EU to reduce legal complexity. Data sovereignty : Some companies and public sector organizations want (or are required) to ensure their data is stored and processed under EU jurisdiction. Performance and latency : Hosting closer to your users generally means faster load times — which also helps SEO and user experience. For many European businesses, especially those handling any form of personal data (even something as simple as contact forms or newsletter signups), EU-based hosting has become the safer, simpler default. Why traditional hosting often falls short Many popular CMS platforms and hosting providers are headquartered outside Europe. While they may offer data centers in the EU, the company’s legal jurisdiction, d

Most multi-agent frameworks for software development organize agents around roles : a product manager agent, a developer agent, a tester agent. ChatDev and MetaGPT pioneered this approach, and it works well for monolithic tasks. But I ran into a wall when I tried to apply it to a real system with multiple independently-deployed services. The Problem with Role-Based Coordination Imagine you have a backend search service and a frontend management console. The backend team implements a new API endpoint. The frontend needs to adapt. In a role-based framework, there's no natural mechanism for this. Both agents are "developers" in the same simulated organization. There's no concept of service boundaries, no versioned contracts, no way to say "the backend changed, and the frontend needs to know exactly what changed." The coordination problem in multi-service development isn't "which role should handle this task" — it's "which service needs to know about this change, and what exactly changed." That reframing led me to build something different. AgentNexus: Coordinating Agents at the Service Granularity AgentNexus is a document exchange center that treats each service as a first-class citizen. Instead of roles, it uses service boundaries as the coordination primitive. Here's how it works: Each service registers as a sub-project with its own document namespace Services publish versioned Markdown documents: requirements, design specs, API docs, config Services subscribe to documents from other services they depend on When a subscribed document changes, the subscriber receives a diff-aware notification containing both the structured diff and the full latest content The whole thing is exposed as an MCP (Model Context Protocol) server running in streamable-HTTP mode, so multiple agents can connect simultaneously from different machines. The Diff-Aware Update Protocol This is the part I'm most proud of. When an agent calls get_my_updates_with_context , it gets back: { "update_id"

I do a fair amount of competitor backlink research, and the workflow always annoyed me: open a dashboard, run a query, export a CSV, eyeball it, copy domains into a doc, switch to email. Lots of tab-hopping for what is fundamentally a data-filtering problem an agent should handle. So I wrapped the backlink API I'd been using into an MCP server. Now I stay in Claude Code (or Cursor, Cline, Zed, Windsurf) and just describe the goal. This is the build: the architecture, the four tools, and the one design decision I'm still not sure about. The data source The server runs on the Common Crawl hyperlink webgraph — about 4.4 billion edges across 120 million domains, published quarterly as Parquet. That matters for an MCP tool specifically: the data is open, so there's no scraped-proprietary-index liability in handing it to an agent, and the same query is reproducible by anyone. The HTTP API in front of it ( CrawlGraph ) does the heavy DuckDB work; the MCP server is a thin TypeScript stdio client over it. Keeping the server thin was deliberate — all the query cost, caching, and quota logic lives server-side, so the MCP package stays a ~300-line wrapper that's easy to audit before you hand it your API key. The four tools backlinks → referring domains for a target, with authority scores gap_analysis → domains linking to your competitors but not to you gap_outreach_targets → the composite play (below) releases → list the Common Crawl snapshots backlinks and gap_analysis map 1:1 to API endpoints. gap_analysis is the interesting primitive: submit your domain plus 2-5 competitors, and it returns every domain that links to at least one competitor but not to you, each tagged with a found_on array listing which competitors it links to. The composite tool, and the decision I'm unsure about Most API-wrapper MCP servers are pure 1:1 mappings. I added one opinionated composite tool, gap_outreach_targets , because the raw gap output isn't the thing you actually want — it's the raw materia