# Reads and writes are separate tools

**A single tool that accepts both safe methods (GET, HEAD, OPTIONS) and unsafe ones (POST, PUT, PATCH, DELETE) is rejected by the Anthropic directory, because no hint can be true for it; split it into a read tool and write tools.**

Check `anthropic-read-write-split` · Anthropic connector directory · default severity: blocking · rubric 2.1.0. Last verified against Anthropic connector pre-submission checklist on 2026-11-18.

## What fails

A tool that takes the HTTP method as an argument can both read and write, so neither hint can be true for it. The checklist rejects a catch-all api_request tool with a method parameter; documenting safe and unsafe uses in the description does not satisfy it.

## The rule

> A single tool that accepts both safe HTTP methods, such as GET, HEAD, and OPTIONS, and unsafe methods, such as POST, PUT, PATCH, and DELETE, is rejected.

Source: [Anthropic connector pre-submission checklist](https://claude.com/docs/connectors/building/review-criteria#separate-read-and-write-tools)

## How to fix it

Split it into a read-only tool (GET) and write tools, ideally one per action: create, update, delete.

1. Replace the catch-all tool with a read-only GET tool and one write tool per action (create, update, delete).
2. Give each its own hints: readOnlyHint: true on the reader, destructiveHint on the writers.
3. Documenting safe and unsafe uses in the description does not satisfy the rule.

Before:

```json
{ "name": "api_request", "inputSchema": { "type": "object", "properties": { "method": { "enum": ["GET", "POST", "DELETE"] }, "path": { "type": "string" } } } }
```

After:

```json
{ "name": "api_get", ... "readOnlyHint": true }  { "name": "api_create", ... }  { "name": "api_delete", ... "destructiveHint": true }
```

### TypeScript SDK

```ts
import { McpServer } from '@modelcontextprotocol/server';
import * as z from 'zod';

const server = new McpServer({ name: 'issues', version: '1.0.0' });

server.registerTool(
  'api_get',
  {
    title: 'API: read',
    description: 'Send a GET request to the Acme REST API (https://api.example.com/docs). Use for reading records only.',
    inputSchema: z.strictObject({
      path: z.string().describe('API path, for example /v1/projects/PRJ-7'),
    }),
    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
  },
  async ({ path }) => ({ content: [{ type: 'text', text: 'Done' }] }),
);
```

### Python SDK

```python
from typing import Annotated

from pydantic import Field
from mcp.server.mcpserver import MCPServer
from mcp.types import ToolAnnotations

server = MCPServer("issues")

@server.tool(
    title="API: read",
    annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False, openWorldHint=False),
)
def api_get(
    path: Annotated[str, Field(description="API path, for example /v1/projects/PRJ-7")],
) -> str:
    """Send a GET request to the Acme REST API (https://api.example.com/docs). Use for reading records only."""
    return "Done"
```

## Questions

### Why is a generic request tool rejected?

Claude auto-approves read-only tools and asks before destructive ones. A tool that can do both cannot be marked either way, so the user loses that protection.

### Do I need one tool per endpoint?

No. One read tool and a few write tools grouped by action are enough; the rule is about mixing safe and unsafe methods in one tool.

## Related checks

- [No generic executor or operation dispatcher](https://isokron.ai/mcp-check/checks/openai-generic-executor)
- [Custom query tools name or link the target API](https://isokron.ai/mcp-check/checks/anthropic-api-docs)
- [Every tool carries the applicable hint](https://isokron.ai/mcp-check/checks/anthropic-hint)
- [Directory review rules for MCP tools](https://isokron.ai/mcp-check/checks/directories)

## Further reading

- [Directory submission pack](https://isokron.ai/mcp-audit/submission-pack)

Counts toward: Anthropic connector directory.

Rubric: https://isokron.ai/mcp-check/rubric

Check your tool list: https://isokron.ai/mcp-check
