# Install Agent-Reach CLI (if not already)
uv tool install https://github.com/Panniantong/Agent-Reach/releases/latest/download/agent-reach.zip
agent-reach setup

curl -fsSL https://raw.githubusercontent.com/haoweid789/agent-reach-mcp/main/install.sh | bash

powershell -ExecutionPolicy ByPass -c "irm https://raw.githubusercontent.com/haoweid789/agent-reach-mcp/main/install.ps1 | iex"

git clone https://github.com/haoweid789/agent-reach-mcp.git
cd agent-reach-mcp
npm install
npm run build

agent-reach-mcp
# or
node dist/index.js

{
  "mcpServers": {
    "agent-reach": {
      "command": "node",
      "args": ["/path/to/agent-reach-mcp/dist/index.js"],
      "env": {
        "PATH": "/home/user/.local/bin:${PATH}"
      }
    }
  }
}

agent-reach-a2a
# or
node dist/a2a-server.js

import httpx

async def search_via_agent_reach(query: str):
    async with httpx.AsyncClient() as client:
        # 1. Send task
        resp = await client.post("http://localhost:8080/rpc", json={
            "jsonrpc": "2.0", "id": 1,
            "method": "tasks/send",
            "params": {
                "message": {
                    "role": "user",
                    "parts": [{"type": "text", "text": query}]
                }
            }
        })
        task = resp.json()["result"]
        
        # 2. Get result (or use SSE for streaming)
        result = await client.post("http://localhost:8080/rpc", json={
            "jsonrpc": "2.0", "id": 2,
            "method": "tasks/get", "params": {"id": task["id"]}
        })
        return result.json()["result"]["task"]["artifacts"]

agent-reach-plugin search zhihu
agent-reach-plugin install @agent-reach/plugin-zhihu

agent-reach-plugin create zhihu --template=basic
cd @agent-reach/plugin-zhihu
npm install
# Edit src/index.ts to implement search/read logic
npm run build
npm publish --access public

@agent-reach/plugin-zhihu/
├── plugin.json          # Manifest (channel, actions, auth, etc.)
├── package.json
├── tsconfig.json
├── src/
│   └── index.ts         # PluginModule with execute(action, params, context)
└── test/
    └── plugin.test.js

import { PluginModule, PluginContext, createPluginResult, PluginHttpClient } from '@agent-reach/plugin-sdk';

const plugin: PluginModule = {
  manifest: { name: '@agent-reach/plugin-zhihu', channel: 'zhihu', ... },
  
  async execute(actionName, params, context) {
    const http = new PluginHttpClient({ baseUrl: 'https://api.zhihu.com' });
    const response = await http.get('/search', { params: { q: params.query } });
    return createPluginResult(response.data.items.map(item => ({
      title: item.title,
      url: item.url,
      author: item.author.name,
      published_at: item.created_time,
      text: item.excerpt,
    })));
  }
};

export default plugin;

agent-reach-mcp/
├── src/                         # @agent-reach/mcp-server
│   ├── index.ts                 # MCP Server (stdio/SSE)
│   ├── a2a-server.ts            # A2A Server (HTTP/JSON-RPC + SSE)
│   ├── plugin-manager.ts        # Plugin lifecycle (install/load/execute)
│   ├── plugin-cli.ts            # Plugin CLI (create/install/search/publish)
│   ├── plugin-sdk.ts            # SDK for plugin authors
│   ├── plugin-types.ts          # TypeScript types
│   ├── channel-definitions.ts   # Re-export of the SDK channel catalog
│   └── cli-wrapper.ts           # Spawns agent-reach CLI
├── packages/
│   ├── sdk/                     # @agent-reach/sdk
│   │   ├── src/client.ts        # ReachClient - the unified entry point
│   │   ├── src/cli-transport.ts # Local CLI transport
│   │   ├── src/a2a-transport.ts # Remote A2A transport
│   │   ├── src/channels.ts      # Canonical 14-channel catalog
│   │   └── src/adapter-utils.ts # Shared helpers for framework adapters
│   ├── langgraph/               # @agent-reach/langgraph
│   ├── crewai/                  # @agent-reach/crewai
│   └── autogen/                 # @agent-reach/autogen
├── scripts/smoke.mjs            # End-to-end smoke test
├── dist/                        # Compiled output
├── install.sh                   # Linux/macOS installer
├── install.ps1                  # Windows installer
└── package.json                 # Workspace root

npm install @agent-reach/sdk

import { ReachClient } from '@agent-reach/sdk';

const reach = new ReachClient();

// Local CLI transport (default)
const result = await reach.execute('github', 'search', { query: 'react hooks', limit: 5 });
for (const item of result.items ?? []) {
  console.log(item.title, item.url);
}

// Remote A2A transport
const remote = new ReachClient({ mode: 'a2a', baseUrl: 'http://localhost:8080' });

// Read any URL - the platform is detected automatically
await reach.read('https://github.com/Panniantong/Agent-Reach');

const result = await reach.execute('github', 'search', {});
if (!result.ok) {
  console.error(result.error?.code);    // UNKNOWN_CHANNEL / MISSING_PARAM / ...
}

import { createReachNode } from '@agent-reach/langgraph';

const node = createReachNode('github', 'search');
const { reach } = await node({ reachArgs: { query: 'react hooks' } });

import { ReachTool } from '@agent-reach/crewai';

const agent = new Agent({
  role: 'Researcher',
  goal: 'Find coffee shops',
  tools: [ReachTool('xiaohongshu', 'search')],
});

import { ReachFunction } from '@agent-reach/autogen';

const assistant = new ConversableAgent({
  name: 'researcher',
  functions: [ReachFunction('bilibili', 'read')],
});

# Build everything (SDK, adapters, then the server)
npm run build

# Build a single package
npm run build --workspace @agent-reach/sdk

# Run all tests
npm run test:packages

# End-to-end smoke test against the real CLI and a live A2A server
node scripts/smoke.mjs

export PATH="$HOME/.local/bin:$PATH"

# Watch mode for MCP server
npm run dev

# Watch mode for A2A server
npm run dev:a2a

# Watch mode for Plugin CLI
npm run dev:plugin

# Run tests
npm test

# Build all
npm run build

# Publish MCP/A2A server
npm publish --access public

# Publish plugin SDK separately
cd plugin-sdk && npm publish --access public