Using Hopsule Context in AI Conversations

This article provides a comprehensive guide on integrating your team's organizational judgment into your artificial intelligence workflows using Hopsule MCP. By the end of this guide, you will understand how to provide AI agents with the necessary context, decisions, and memories to ensure they act as informed partners rather than generic assistants.

In the modern engineering landscape, the greatest challenge is not the generation of code, but the preservation of context. Hopsule MCP (Model Context Protocol) serves as the bridge between your team's established governance and the AI tools you use daily. By leveraging Hopsule MCP, you ensure that every suggestion made by an AI agent is grounded in your team’s accepted decisions and historical memories, effectively turning enforcement into an act of remembrance.

Prerequisites

Before you can begin leveraging Hopsule context within your AI conversations, ensure you have completed the following requirements:

• An active Hopsule account with at least one project configured in the Hopsule Dashboard.

• A set of Accepted Decisions within your project to serve as enforceable constraints.

• A Personal Access Token generated from your user profile settings.

• An MCP-compatible AI client (such as Cursor, Claude Desktop, or other supported IDEs).

• The Hopsule CLI installed locally if you intend to manage tokens and project status via the terminal.

Setting Up Hopsule MCP

The integration process involves connecting your AI client to the Hopsule API through the Model Context Protocol. This allows the AI to query your Knowledge Graph (also known as the Brain) in real-time.

1. Generating Your Access Token

Security is a baseline guarantee at Hopsule. All data is protected by TLS 1.3 in transit and AES-256 at rest. To connect an external agent, you must first create a secure gateway.

1. Log in to the Hopsule Dashboard.

2. Navigate to the Settings menu by clicking your avatar in the bottom-left corner.

3. Select the Personal Access Tokens tab.

4. Click the Generate New Token button.

5. Provide a descriptive name for the token (e.g., "Cursor Integration" or "Claude Desktop").

6. Set an expiration date according to your organization’s security policy.

7. Click Create and copy the token immediately. For your protection, Hopsule does not store the raw token after this moment.

2. Configuring the AI Client

Once you have your token, you must configure your AI client to communicate with the Hopsule MCP server. While the exact interface varies by tool, the general procedure remains consistent.

1. Open the configuration settings of your MCP-compatible AI agent.

2. Add a new MCP server entry named "Hopsule".

3. Provide the Hopsule MCP endpoint URL (refer to the Hopsule Dashboard integration page for the current regional endpoint).

4. Add an environment variable or header named HOPSULE_API_KEY and paste your generated token.

5. Save the configuration and restart the AI agent if necessary.

3. Defining the Context Scope with Capsules

Not every AI conversation requires access to every decision ever made by your organization. To prevent context dilution, Hopsule utilizes Context Packs (also known as Capsules).

A Capsule is a portable bundle of decisions and memories designed to survive time and system changes. To manage which Capsules are visible to your AI agent:

1. In the Hopsule Dashboard, navigate to the Capsules section.

2. Identify the Capsule containing the relevant decisions for your current task.

3. Ensure the Capsule status is set to Active. AI agents connected via Hopsule MCP can only see Active or Frozen Capsules; Draft Capsules are hidden to prevent the enforcement of unvetted ideas.

4. If you are working on a specific project, ensure that project is linked to the Capsule in the Capsule Settings.

Interacting with Decisions and Memories

Once the connection is established, your AI agent becomes context-aware. It no longer operates in a vacuum but functions within the governance framework of your organization.

Querying Decisions

You can now ask the AI about the constraints of your project. For example, you might ask: "What are our accepted decisions regarding architectural patterns for this project?"

The AI will query the Hopsule API, retrieve the relevant Accepted Decisions, and present them to you. Because Hopsule treats decisions as first-class, enforceable entities, the AI can distinguish between a Draft decision (which it will ignore) and an Accepted decision (which it will treat as a binding rule).

Accessing Memories

Decisions tell the AI *what* to do; Memories tell the AI *why*. Memories are persistent, append-only entries that preserve the reasoning and history of your team’s choices. When an AI agent accesses a memory, it gains insight into the lessons learned by your team in the past.

If an AI suggests a change that contradicts a past lesson, you can prompt it: "Check our memories for previous failures related to this implementation." The AI will then retrieve the linked memories, allowing it to avoid repeating historical mistakes. Remember: Hopsule memories are never deleted and never overwritten, ensuring full traceability for the entire lifecycle of your engineering organization.

Using Hopper for Advisory Guidance

While the MCP connection provides the raw context, Hopper—our built-in AI assistant—provides advisory guidance. Hopper uses RAG-powered technology to analyze your team's existing decisions and memories. Within your AI conversation, you can use Hopper to:

• Draft new decisions based on the current conversation.

• Detect potential conflicts between a proposed code change and an existing Accepted Decision.

• Explain the nuances of a complex decision that may have multiple linked memories.

It is important to note that Hopper and Hopsule MCP are strictly advisory. In the Hopsule philosophy, AI agents never make decisions autonomously. Humans retain the authority to move a decision from Pending to Accepted.

Enforcement in the Development Workflow

To see the full power of Hopsule context, use Hopsule for VS Code alongside your AI agent. While the AI agent uses the context to generate code, the IDE extension provides inline enforcement. If the AI generates code that contradicts an accepted decision, the Hopsule IDE Extension will surface a warning directly in your editor.

This dual-layer approach—contextual generation via MCP and authoritative enforcement via the IDE—ensures that your organizational judgment is maintained throughout the development lifecycle.

Tips and Best Practices

• Keep Decisions Atomic: For the best results with AI agents, ensure each decision is focused on a single commitment. This makes it easier for the AI to retrieve and apply the specific constraint relevant to the current code block.

• Leverage Tags: Use the tagging system in the Hopsule Dashboard to categorize decisions. AI agents can filter context by tags, allowing for more precise retrieval during specialized tasks (e.g., "Security", "Frontend", "Performance").

• Link Memories to Decisions: Always append a memory to a decision when the reasoning changes or new lessons are learned. This provides the AI with a chronological narrative of your team's growth.

• Use Frozen Capsules for Compliance: If you are working on a project with strict regulatory requirements, move the relevant decisions into a Frozen Capsule. This ensures the context remains immutable for the duration of the audit period.

• Regularly Audit the Knowledge Graph: Use the Knowledge Graph (Brain) visualization in the Dashboard to identify orphaned decisions or memories that lack context. A well-connected graph provides better "navigational" data for AI agents.

• Solo Mode: If you are a solo developer, do not skip the memory-making process. Hopsule is designed to act as your personal "portable memory," helping you remember why you made specific choices six months ago when you return to a project.

Troubleshooting

If you encounter issues while using Hopsule context in your AI conversations, refer to the table below for common causes and solutions.

Advanced Usage: Hopsule API and Custom Integrations

For organizations with complex workflows, the Hopsule API provides programmatic access to your decisions, memories, and capsules. You can build custom scripts that use the API to feed context into internal LLM platforms or CI/CD pipelines. This ensures that even outside of standard AI agents, your organizational judgment remains the source of truth.

When using the API, remember that the same governance rules apply: AI can read context but cannot mutate the state of a decision. All mutations must be performed by an authorized user via the Hopsule Dashboard, Hopsule CLI, or the Hopsule IDE Extension.

The Hopsule Philosophy: Enforcement is Remembrance

By integrating Hopsule context into your AI conversations, you are practicing a new form of engineering governance. We believe that enforcement should not feel like control; it should feel like remembrance. When your AI agent "remembers" a decision your team made three months ago, it is not restricting your creativity—it is preserving your progress.

Hopsule ensures that as people join or leave your team, and as your tech stack evolves, the core reasoning and commitments that define your organization remain accessible and enforceable. Your AI tools are only as good as the context they possess. With Hopsule MCP, you give them the best context possible: your team's collective wisdom.

Related Articles

• Managing Context Packs and Capsules for Project Portability

• Understanding the Decision Lifecycle: From Draft to Deprecated

• Setting Up Inline Enforcement with Hopsule for VS Code

• Visualizing Context: A Guide to the Hopsule Knowledge Graph