Attachpad

Inspiration

AI agents are only as reliable as the context they receive.

Attachpad was inspired by a gap between making information available to an agent and giving users granular control over exactly how that information is exposed and prioritized.

DataHub already provides an MCP server that allows agents to access DataHub's rich context and capabilities. We did not want to rebuild that functionality.

Instead, we asked a different question:

What if users had a dedicated control plane for deciding what context an agent should see, how important it is, and how it should be retrieved?

That idea became Attachpad.

Attachpad is a prototype for a human-controlled context plane that could sit alongside or eventually be implemented natively within DataHub's MCP experience.

What It Does

Attachpad is a context control center for AI agents and MCP clients.

Users can:

• Upload files or import public webpages and PDFs
• Organize context manually
• Assign granular priorities to documents
• Control which information is exposed to an agent
• Create session-scoped context workspaces
• Connect an agent through a session-scoped MCP interface

Once connected, an agent can:

• Discover available context
• Search indexed content
• Read individual documents
• Retrieve focused context relevant to a query
• Respect the user's organization and prioritization of context

The important distinction is that Attachpad is not another MCP server competing with DataHub's MCP server.

DataHub already solves the problem of exposing DataHub context to agents.

Attachpad explores the complementary problem of giving humans a granular control plane over that context.

How We Built It

Attachpad combines a web-based context management interface with a Python context retrieval service.

The application uses:

• React Router
• Tailwind CSS
• shadcn/ui
• Python for the core context-fetching endpoint
• DataHub Agent Context Kit
• DataHub as the underlying context platform
• Elasticsearch for indexed document storage and retrieval
• MCP for agent connectivity

Documents from different sources are normalized into Markdown before indexing, creating a consistent representation for retrieval.

The core context-fetching path is implemented in Python and integrates with DataHub Agent Context Kit, allowing Attachpad to participate in DataHub's agent context ecosystem.

Elasticsearch provides the indexed retrieval layer for Attachpad's imported documents.

The architecture separates the responsibilities:

Human control → managed context → retrieval → agent

rather than treating the agent's context as an uncontrolled collection of available documents.

Challenges We Ran Into

Some of the biggest challenges included:

• Designing a granular context-control model that remains intuitive for users
• Keeping browser sessions and agent sessions synchronized
• Building the primary context retrieval path in Python
• Integrating DataHub Agent Context Kit into the retrieval workflow
• Designing document ingestion that works consistently across PDFs and webpages
• Safely importing public URLs while handling redirects and preventing private-network access
• Converting PDFs into useful, agent-readable Markdown
• Determining how user-defined priorities should interact with search relevance

Accomplishments We're Proud Of

• Built a dedicated UI for granular context control
• Added manual context organization and document prioritization
• Implemented PDF and webpage ingestion with automatic Markdown normalization
• Built Elasticsearch-backed document indexing and retrieval
• Implemented the primary context-fetching service in Python
• Integrated DataHub Agent Context Kit
• Connected the controlled context layer to agents through MCP
• Supported both broad context retrieval and focused search
• Created session-scoped workspaces without requiring user accounts

Most importantly, we demonstrated a concept that could potentially be implemented directly within DataHub's existing MCP ecosystem: a user-facing control plane that allows people to explicitly shape the context made available to agents.

What We Learned

We learned that MCP is only one layer of the agent-context problem.

DataHub's MCP server already provides a powerful mechanism for agents to access DataHub context. The missing question is often what a particular human wants that agent to see and prioritize for a particular task.

That led us to distinguish between two related concepts:

Context access — what an agent can retrieve.

Context control — what a human wants it to retrieve.

Attachpad focuses on the second.

We also learned that:

• Context should be treated as a controllable resource rather than an undifferentiated information pool.
• User-defined priorities can complement algorithmic relevance.
• Session-scoped context can provide a useful boundary for agent tasks.
• Document normalization is important when heterogeneous sources become agent context.
• A context control layer does not need to replace an existing MCP server; it can operate as a policy and orchestration layer around it.
• The best version of this idea may ultimately be native to the platform providing the underlying context.

What's Next for Attachpad

The next step is to explore how this concept could integrate more deeply with DataHub itself.

Potential directions include:

• A native context control panel for DataHub MCP
• Provenance-aware context selection
• Context versioning
• Shared team context configurations
• Agent feedback on retrieved context
• More sophisticated ranking that combines DataHub metadata, search relevance, and human-defined priorities

Ultimately, Attachpad does not need to become a replacement for DataHub's MCP server.

Our goal is to demonstrate a missing interaction layer around it: giving humans a precise control plane over the context their agents consume.

If that capability proves useful, the natural long-term home for it could be DataHub itself.

Built With

• agent-context-kit
• datahub
• fastapi
• javascript
• python
• react
• sqlite