Skip to main content
Glama
hexa01

agent-content-mcp

by hexa01
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Remote

agent-content-mcp

MCP server for Django sites: AI agents read and edit content through tools generated from the site.

Works with Claude Code, Claude Desktop, Cursor and other MCP clients, and any Django site running django-agent-content. Its tools aren't hard-coded: at startup it reads the site's API description and creates tools for whatever the site has registered, such as list_posts, update_post or publish_post. One server for every site, with no code to edit.

MCP client ──stdio──> agent-content-mcp ──HTTPS + API key──> site /api/agent/ ──> Django models

Requirements

  • A Django site with django-agent-content installed and an API key from it (python manage.py agent_content_key, or the site's admin under Agent content › API keys).

  • uv to run the server: curl -LsSf https://astral.sh/uv/install.sh | sh

Related MCP server: mcp-django-server

Setup

Run once, in the project folder where you use Claude Code:

claude mcp add agent-content \
  -e AGENT_CONTENT_URL=https://example.com/api/agent/ \
  -e AGENT_CONTENT_KEY=ac_your_key \
  -- uvx --from git+https://github.com/hexa01/agent-content-mcp agent-content-mcp

Then start Claude Code there; claude mcp list shows whether it connected.

Setting

Meaning

AGENT_CONTENT_URL

The site's API root. Must be https://; plain http:// is accepted only for localhost.

AGENT_CONTENT_KEY

The API key. It is stored in your Claude Code configuration, not in any repository.

Scopes

claude mcp add stores the entry for the current project, visible only to you. Other options:

Option

Stored in

Available

(default)

your Claude Code config

you, in this project

--scope user

your Claude Code config

you, in all projects

--scope project

.mcp.json in the repository

anyone opening the repository; use "AGENT_CONTENT_KEY": "${AGENT_CONTENT_KEY}" so the key stays in each person's environment

Other MCP clients

Any client that starts stdio servers can run it with the same command and environment variables, for example Claude Desktop's claude_desktop_config.json:

{
  "mcpServers": {
    "agent-content": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/hexa01/agent-content-mcp", "agent-content-mcp"],
      "env": { "AGENT_CONTENT_URL": "https://example.com/api/agent/", "AGENT_CONTENT_KEY": "ac_your_key" }
    }
  }
}

Tools

Each resource the site registers becomes a set of tools:

Tools

When

list_<name>, get_<item>

always

create_<item>

the resource allows creating

update_<item>

the resource has writable fields; only the given fields change

<action>_<item>

for each registered action, e.g. publish_post

get_<item>_<list>, set_<item>_<list>

for each inline list; set_ replaces the whole list

get_<name>, update_<name>

for single-object resources such as site settings

Descriptions come from the site's models (labels, help texts, limits, choices) and resource descriptions, so better documented models give agents better guidance. To see the tools for a site without an MCP client:

AGENT_CONTENT_URL=https://example.com/api/agent/ AGENT_CONTENT_KEY=ac_... \
  uvx --from git+https://github.com/hexa01/agent-content-mcp agent-content-mcp --check

Asking before public changes

To have Claude Code ask for approval before a tool runs, add it to the project's .claude/settings.json:

{ "permissions": { "ask": ["mcp__agent-content__publish_post"] } }

Safety

  • The key is sent only over HTTPS (or to localhost). The site stores only its hash and can expire or revoke it.

  • What the key can do is limited by its Django user's permissions. The API has no delete operations.

  • Every change is recorded in the site's admin history under the key's user.

Development

git clone https://github.com/hexa01/agent-content-mcp.git && cd agent-content-mcp
poetry install                  # creates .venv/ here
.venv/bin/agent-content-mcp --check

To use a local checkout from Claude Code: claude mcp add agent-content -e ... -- uvx --from /path/to/agent-content-mcp agent-content-mcp.

File

Purpose

agent_content_mcp/server.py

MCP server over stdio; settings; --check

agent_content_mcp/tools.py

builds tools from the API description and maps calls to requests

agent_content_mcp/client.py

HTTP client: authentication, the HTTPS rule, readable errors

License

MIT

Available Tools

1 tool
agent_content_statusB
Read-only

Explains why the site's content tools are unavailable.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the diagnostic intent, but says nothing about what the tool inspects, whether it always returns a reason, or how failures/unavailability are surfaced — useful context, but thin beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single short sentence with no waste, and the operative concept (why content tools are unavailable) is front-loaded. It is arguably under-specified rather than over-long, which costs it the top score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description carries the burden of describing the return, and it does not — an agent cannot tell whether it receives a cause, a status code, or a list of disabled tools. For a zero-parameter diagnostic this is a meaningful gap despite the simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters and the schema is fully specified (empty object, 100% coverage), so there are no parameter semantics to explain. Baseline of 4 applies for a no-argument tool.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific function — diagnosing why the site's content tools are unavailable — which is more than a restatement of the name. However, it leaves ambiguity about what is actually returned (a status object? a prose explanation? a cause list?) and whether unavailability is a precondition or merely the common case.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: an agent can infer 'call this when content tools appear to be unavailable', but the description never says so explicitly, nor states prerequisites or what conditions make it the right call. With no siblings there is no routing burden, so the implied context is minimally adequate.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 1 tool updatev0.1.0
    • First observedagent_content_status
Deploy Server
Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

TDQS

B3.1/5.0

Scored across 1 tool

Disambiguation5/5

With only a single tool, there is no possibility of overlap or misselection between tools. The lone tool's purpose (explaining tool unavailability) is unambiguous on its face.

Naming Consistency4/5

The single name 'agent_content_status' uses a clean snake_case noun_qualifier pattern and is well-formed. However, a one-tool surface provides no real pattern to validate consistency against, so it cannot earn a full 5.

Tool Count1/5

The server exposes exactly one trivial status/stub tool, an extreme mismatch for a server named agent-content-mcp that implies content management capabilities. There is essentially no functional surface to speak of.

Completeness1/5

The only tool merely explains why content tools are unavailable, meaning the entire content lifecycle (read/create/update/delete) is absent. This is a severely incomplete surface for the stated domain.

Maintenance

ActivityMaintained
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

  • mcp-django-server

    99rig
    A
    license
    Not graded
    quality
    D
    maintenance
    A Django MCP server that exposes tools and resources to AI agents using simple decorators, with auto-discovery, type safety, and custom authentication.
    MIT

  • django-mcp-inspector

    StuartMacKay
    F
    license
    Not graded
    quality
    D
    maintenance
    Exposes Django runtime information (settings, apps, URLs, models, migrations) as MCP resources for AI agents to inspect a live Django project without static analysis.
    -

  • drf-mcp

    ziyacivan
    A
    license
    Not graded
    quality
    C
    maintenance
    Exposes Django REST Framework APIs as MCP tools for AI agents via the Model Context Protocol, with automatic discovery and security.
    1
    MIT