Tagged articles
JSON-RPC
45 articles · Page 1 of 1
This article explains why MCP clients must distinguish between JSON-RPC protocol errors and tool business failures (isError: true), outlining three error categories—request unintelligible, tool execution failure, and result validation failure—and showing how proper separation enables correct retry logic, user feedback, and audit logging.
JSON-RPCMCPProtocol Design
0 likes · 8 min read

This article explains the Model Context Protocol (MCP) by tracing a complete tool call flow—from tool discovery via tools/list, model intent generation, MCP routing, server execution, to result return—detailing JSON-RPC message formats, stdio and HTTP transports, and the roles of Model, Host, Client, and Server.
AI toolingFunction CallingJSON-RPC
0 likes · 24 min read

The article explains how ACP v2 decouples message insertion from turn completion, making session/prompt responses only acknowledge insertion while deferring completion, errors, and cancellations to session-level state_update notifications, requiring clients to maintain separate tracking for submission receipt and session activity.
ACPJSON-RPCProtocol Design
0 likes · 15 min read

This guide explains the Model Context Protocol (MCP), an open standard that solves the M×N integration problem between AI applications and tools by defining three roles (Host, Client, Server), three capability types (Tools, Resources, Prompts), and two transports (stdio, HTTP), with a minimal Python server example and integration steps for Trae, Claude, and Cursor.
AI agentsAI tool integrationFastMCP
0 likes · 10 min read

This article dissects OpenAI's Codex Harness, a 146K-line Rust workspace of 135 crates that powers ChatGPT, CLI, and IDE extensions as an embeddable agent platform, detailing its agent loop, context engineering, JSON-RPC protocol, multi-OS sandboxing, and multi-agent architecture with measurable benchmark gains on ARC-AGI-3.
Agent ArchitectureCodex HarnessJSON-RPC
0 likes · 33 min read

The article explains how Hermes implements the Agent Communication Protocol (ACP) to become a standard, first‑class Agent server for IDEs like VS Code, Zed, and JetBrains, detailing the protocol’s design, session management, event bridging, and IDE integration benefits.
ACPHermesIDE integration
0 likes · 13 min read

The article explains the design of Hermes' terminal UI gateway, detailing why the TUI does not import the Agent directly, how JSON‑RPC over stdio or WebSocket enables local and remote modes, and how slash commands are processed through a two‑layer routing system with a dedicated _SlashWorker subprocess and a pure‑function crash‑recovery plan.
Crash RecoveryHermesJSON-RPC
0 likes · 16 min read

The article examines the emerging A2A (Agent‑to‑Agent) protocol, tracing its evolution from function calling to MCP and finally A2A, and evaluates its core concepts, security model, task lifecycle, transport options, design guidelines, and operational best practices for building interoperable AI agent systems.
A2AAgent CardAgent Communication
0 likes · 15 min read

The article examines Model Context Protocol (MCP), introduced by Anthropic in November 2024, tracing its rapid adoption, architectural design—including Host/Client/Server roles, transport layers, security and observability practices—and outlines production guidelines, future roadmap, and current limitations.
AI integrationJSON-RPCMCP
0 likes · 19 min read

This article explains the Chrome DevTools Protocol (CDP), its WebSocket‑based JSON‑RPC communication model, domain architecture, and how AI agents and tools like Playwright and Puppeteer rely on it, while providing practical TypeScript examples, common pitfalls, and tips for direct CDP usage.
CDPChrome DevTools ProtocolJSON-RPC
0 likes · 23 min read

The article dissects the Model Context Protocol (MCP), showing how it transforms the M×N integration explosion into a linear M+N model, details its four-component architecture, compares it with traditional Function Calling, provides a TypeScript server example, and outlines emerging ecosystem and security considerations.
AI tool integrationFunction CallingJSON-RPC
0 likes · 17 min read

The article explains MCP (Model Context Protocol) as a standardized interface for AI applications to access external data sources and tools, compares it with function calling, outlines its security considerations, architecture, resource types, and transport options such as Stdio and Streamable HTTP.
AI applicationsJSON-RPCMCP
0 likes · 5 min read

This article explains how the Agent Client Protocol (ACP) standardizes communication between AI coding agents and editors or messaging platforms, describes OpenClaw's acpx plugin that connects ACP to Discord and Telegram, and provides detailed configuration, command reference, comparison with sub‑agents, practical use cases, and troubleshooting guidance.
ACPJSON-RPCMessaging Platforms
0 likes · 18 min read

This article explains the A2A (Agent‑to‑Agent) protocol, AgentCard format, service discovery, JSON‑RPC communication, task lifecycle, credential protection, and provides a step‑by‑step Go SDK demo for building and invoking multi‑agent systems on the AgentRun cloud‑native platform.
A2AAgentRunCloudNative
0 likes · 20 min read

The article details how Verge, an AI‑assisted edge gateway built on the open‑source driver‑box framework, transforms a pure engine into a full‑featured, lightweight IoT platform by decoupling cloud and edge, offering rapid device integration, visual model editing, Lua scripting, and flexible deployment for smart building, industrial automation, and hobbyist labs.
Device ManagementEdge ComputingGo
0 likes · 11 min read

This article walks through the complete development of a minimal Model Context Protocol (MCP) server using Spring Boot 3 and Server‑Sent Events, illustrating how OpenSpec drives the workflow from proposal and task breakdown to design, implementation, testing, and integration with Claude Code.
API DesignJSON-RPCJava
0 likes · 13 min read

This tutorial explains how the Model Context Protocol (MCP) standardizes AI agent integration by replacing custom tool code with a JSON‑RPC based, auto‑discovered ecosystem, walks through configuration, core loading logic, code implementation, a runnable example, and compares MCP with traditional tool use.
AI AgentJSON-RPCMCP
0 likes · 8 min read


Qborfy AIDec 17, 2025 · Artificial Intelligence
The article introduces the Model Context Protocol (MCP), an open Anthropic standard that creates a secure, standardized, bidirectional bridge between large language models and external tools, then walks through its architecture, core components, Python server and client code, OpenAI integration, usage flow, ecosystem and future outlook.
AI integrationFastMCPJSON-RPC
0 likes · 8 min read

This article explains the MCP communication protocol, detailing how JSON‑RPC 2.0 structures requests and responses, how tools are listed and invoked via HTTP SSE, and walks through the full client‑server lifecycle with concrete code examples and diagrams.
AnthropicBackendHTTP SSE
0 likes · 13 min read

This guide introduces Workerman‑JsonRpc, a lightweight PHP RPC framework built on Workerman, detailing its key features, environment requirements, installation steps, synchronous and asynchronous client usage, server implementation, and built‑in monitoring capabilities for creating scalable network applications.
BackendJSON-RPCPHP
0 likes · 7 min read

The article explains MCP's three communication modes—stdio, SSE, and Streamable HTTP—focuses on the Streamable HTTP protocol introduced in 2025, and walks through its four lifecycle phases with detailed JSON‑RPC request and response examples for initialization, runtime operations, updates, and closure.
JSON-RPCMCPStreamable HTTP
0 likes · 8 min read

This article demystifies the Model Context Protocol (MCP) by walking through a practical fetch-mcp example, then detailing the JSON-RPC 2.0 application layer interactions — initialization, tool listing, and tool calling — and comparing STDIO versus Streamable HTTP transport layers for remote MCP server communication.
AI EngineeringJSON-RPCLLM Tool Integration
0 likes · 11 min read

This article explains the MCP framework that standardizes AI tool invocation using JSON‑RPC, outlines its client‑server architecture, details communication methods such as STDIO, SSE and streamable HTTP, and provides a Spring AI demo showing tool registration, discovery, and execution.
AIFunction CallingJSON-RPC
0 likes · 14 min read

This article explains the MCP framework’s architecture, execution flow, JSON‑RPC communication, and lifecycle, showing how it standardizes AI function calling and tool integration using Spring AI, with code examples and comparisons of communication methods.
AI tool integrationFunction CallingJSON-RPC
0 likes · 14 min read

This guide explains the lightweight, stateless JSON-RPC 2.0 protocol, detailing its request and response structures, error handling, notifications, batch processing, and real‑world use cases such as AI tool integration, blockchain node interaction, and IoT device communication.
APIBackendJSON-RPC
0 likes · 6 min read

This article introduces the JSON-RPC 2.0 protocol, demonstrates how to integrate the jsonrpc4j library into a Spring Boot 3.4.2 project, and provides step‑by‑step code examples for defining services, exposing them via beans or annotations, configuring various client proxies, handling errors, and implementing streaming socket communication.
JSON-RPCJavaRPC
0 likes · 10 min read

This article explains the limitations of the original Stdio and HTTP SSE communication modes for MCP, introduces the Streamable HTTP protocol that resolves those issues, and provides a step‑by‑step Python implementation of both a Streamable HTTP MCP server and a matching client, complete with environment setup, FastAPI code, JSON‑RPC handling, and tool‑calling examples.
FastAPIJSON-RPCMCP Protocol
0 likes · 28 min read

MCP (Model Context Protocol) is an emerging open‑standard that lets large language models interact with tools, data sources, and services through a unified JSON‑RPC or gRPC interface, addressing fragmentation, data silos, and low development efficiency while offering a flexible, community‑driven ecosystem with clear advantages and current limitations.
AI Tool CallingJSON-RPCLLM integration
0 likes · 14 min read

The MCP 2025‑03‑26 release introduces mandatory OAuth 2.1 with PKCE, a single‑endpoint Streamable HTTP transport, required JSON‑RPC batch processing, richer tool metadata, structured progress notifications, audio multimodal support, and robust session management, all backed by extensive security hardening and performance gains.
API SecurityJSON-RPCMCP
0 likes · 14 min read

The updated MCP protocol (2025‑03‑26) introduces JSON‑RPC batch processing and enhanced tool annotations, enabling AI agents to send multiple requests in a single call, improve performance, and provide richer metadata for safer, more transparent tool usage.
JSON-RPCMCPPython
0 likes · 9 min read

The MCP 2025‑03‑26 release replaces the implicit OAuth 2.0 flow with mandatory OAuth 2.1 PKCE, introduces a single‑endpoint Streamable HTTP protocol, enforces JSON‑RPC batch processing, adds multimodal audio support, tool metadata annotations and progress messaging, and outlines migration steps for developers and operators.
AI toolsAPIJSON-RPC
0 likes · 15 min read


DevOpsApr 29, 2025 · Artificial Intelligence
This tutorial explains the Model Context Protocol (MCP) for integrating large language models with external data sources, details its architecture, connection lifecycle, and core JSON‑RPC features, and provides a step‑by‑step Python implementation that fetches real‑time tech news and integrates with Claude Desktop.
AI integrationJSON-RPCMCP
0 likes · 9 min read


ArchitectApr 26, 2025 · Artificial Intelligence
This article provides a comprehensive overview of the Model Context Protocol (MCP), explaining its origins, architecture, and how it standardises AI tool calling by enabling developers to build MCP servers and clients with TypeScript and Python, register resources, tools and prompts, and orchestrate model‑driven tool execution via JSON‑RPC.
AI integrationJSON-RPCMCP
0 likes · 16 min read

This article demystifies the Model Context Protocol (MCP) by explaining its SSE‑based communication flow, showing how to implement a lightweight MCP server in Python, comparing it with REST, MQ and WebSocket, and highlighting its stateful bidirectional RPC model for AI integration.
JSON-RPCMCPPython
0 likes · 15 min read


DevOpsApr 16, 2025 · Artificial Intelligence
This article provides a comprehensive overview of the Model Context Protocol (MCP), explaining its purpose in unifying AI tool calls, detailing its architecture, and walking through step‑by‑step development of MCP servers and clients with TypeScript and Python examples, while showcasing real‑world use cases and debugging tips.
AI tool integrationJSON-RPCMCP
0 likes · 15 min read


ArchitectMar 8, 2025 · Artificial Intelligence
This article provides a comprehensive overview of the Model Context Protocol (MCP), explaining its purpose, core components, differences from traditional APIs, detailed architecture, message types, connection lifecycle, error handling, and step‑by‑step instructions for building and using MCP servers to enable AI agents to act on real‑world data and tasks.
AI automationAI tool integrationClaude
0 likes · 12 min read

This article explains the fundamentals of device communication, from simple LAN setups using hubs and switches to internet protocols like HTTP, then guides the design of custom communication protocols, illustrates JSON‑RPC over sockets, and explores CAN bus specifics, offering practical code examples and architectural diagrams.
CANJSON-RPCRPC
0 likes · 17 min read

This article explains how to construct and send Ethereum JSON‑RPC calls such as net_version through a WebSocket connection using the Web3j Java library, including source code analysis, request construction, and a practical example with console output.
BlockchainEthereumJSON-RPC
0 likes · 5 min read

This article explains the fundamentals of Remote Procedure Call (RPC), explores how data moves across OSI layers, compares HTTP and RPC, and provides a complete Node.js JSON‑RPC example with code, error handling, and real‑world use cases such as Chrome DevTools Protocol.
Chrome DevToolsJSON-RPCRPC
0 likes · 13 min read

This article explains how to build a versatile browser message‑communication library that works across iframes, Web Workers, ServiceWorkers, BroadcastChannel and other MessagePort‑like objects, using a unified interface design, TypeScript typings, event‑driven architecture and JSON‑RPC for reliable remote procedure calls.
JSON-RPCPostMessageRPC
0 likes · 13 min read

This article explores the core principles of asynchronous programming, explains how Prefresh enables fast refresh for Preact, showcases a comprehensive web animation tutorial, introduces the Doodle Ipsum illustration placeholder service, and details Theia's JSON‑RPC communication protocol for Cloud IDE extensions.
Async ProgrammingJSON-RPCWeb animation
0 likes · 9 min read

This article explains how to design, implement, and deploy a high‑performance Go service that uses an upgraded sego tokenizer to load custom sensitive‑word dictionaries, provide JSON‑RPC detection, support hot‑reloading, and scale across multiple data centers for live‑stream platforms.
GoHot ReloadJSON-RPC
0 likes · 7 min read

When sending Ethereum transactions via JSON‑RPC, a mismatched nonce can cause the transaction hash to appear while the transaction remains unconfirmed, staying in the queue indefinitely until the nonce order is corrected.
EthereumJSON-RPCnonce
0 likes · 4 min read

This guide walks you through using Zabbix's JSON‑RPC API with curl to authenticate, retrieve host and item IDs, fetch historical metrics for specific time ranges, and access additional system information such as version, macros, and media settings.
APIJSON-RPCcurl
0 likes · 9 min read


ITPUBMar 14, 2016 · Backend Development
This article explains how Riot's Game Data Server (GDS) replaces chaotic .ini editing with a JSON‑based RPC system, introduces property macros for type safety, and uses layered versioning to eliminate merge conflicts and simplify multi‑tool workflows for League of Legends development.
BackendGDSJSON-RPC
0 likes · 10 min read
