Skip to main content
Remyx exposes its ExperimentOps tools via the Model Context Protocol (MCP). This means Claude Code can read your experiment’s context, understand the technique you’re testing, and generate an implementation PR through natural tool calls. This tutorial walks through finding an idea, creating an experiment from it, connecting Claude Code, and generating a PR.

​
What this sets up

  • An experiment created from a search result or recommendation
  • Claude Code connected to the Remyx MCP server
  • A PR implementing the experiment’s technique in your target repo
Prerequisites: A Remyx account with an API key, Claude Code installed (or you’ll install it in Step 1), and a GitHub repo you want to implement into.

​
Step 0: Find an Idea and Create an Experiment

Before Claude Code can implement anything, you need an experiment with a linked resource and target repository. There are three ways to get there:

​
Option A: Search for a technique

  1. Go to Search and enter a query related to your project (e.g., “multi-hop retrieval for complex queries”)
  2. Browse the results. Resources with the Runnable environment badge have pre-built Docker images.
  3. Click View on a result to open the detail page. Use the Chat tab to ask questions about the method. Use the Annotations tab to highlight key passages and add notes.
  4. Click Create Experiment from the resource detail page
  5. Fill in the experiment name, hypothesis, target metric, tags, and target repository (owner/repo)
  6. Click Create

​
Option B: Start from a recommendation

  1. Go to Feed to see your personalized recommendations
  2. Find a recommendation that matches a direction you want to explore
  3. Click View, then Create Experiment
  4. Fill in the experiment details and click Create

​
Option C: Start from Insights

  1. Go to Insights to see which experiment directions are producing results
  2. Expand a high-signal cluster and look at the Recommended resources column
  3. Click Start Experiment on a recommendation. The cluster’s tag and the current project are pre-filled.
  4. Fill in the remaining details and click Create
After creation, the experiment detail page loads. The Origin section generates a launch context within a few seconds: key methods, abstract excerpt, target repo, and an implementation plan grounded in your repo’s file paths.

​
Step 1: Get Your Remyx API Key

  1. Go to engine.remyx.ai/account
  2. Navigate to API Access
  3. Create a new key or copy your existing one

​
Step 2: Connect Claude Code to Remyx

Add the Remyx MCP server to your Claude Code configuration. Open your settings file:
Edit ~/.claude/settings.json:
{
  "mcpServers": {
    "remyx": {
      "type": "http",
      "url": "https://mcp.remyx.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_REMYX_API_KEY"
      }
    }
  }
}

​
Verify the Connection

Start Claude Code and ask: 
What Remyx tools do you have available?
Claude should list the available MCP tools: get_digest, get_experiments, create_experiment, update_experiment, log_decision, etc.

​
Step 3: Discover Your Experiments

Ask Claude Code to list your experiments: 
Show me experiments in my Customer Support AI initiative
Claude calls get_experiments and returns your experiment list with names, statuses, deltas, and decisions.

​
Step 4: Get the Implementation Context

Pick a research-sourced experiment and ask for its implementation context: 
Get the implementation context for the "Hybrid search with re-ranking" experiment
Claude calls get_experiment_context and returns the launch context:
  • Resource metadata: Title, abstract excerpt, key methods
  • Docker environment: Reference to a pre-built environment (if available)
  • Target repo structure: File tree of your repository
  • Implementation plan: AI-generated plan referencing actual file paths

​
Step 5: Generate the Implementation

With the context loaded, ask Claude to implement it: 
Implement the technique from this experiment in my repo. 
Follow the implementation plan from the launch context.
Claude Code will:
  1. Read the implementation plan and understand the technique
  2. Navigate your repository structure
  3. Generate the code changes
  4. Create a branch and open a PR

​
Or use the automated pipeline

For a fully automated run: 
Run the implementation pipeline for the "Hybrid search with re-ranking" experiment
Claude calls run_experiment_implementation, which triggers the end-to-end pipeline: clone, implement, push, PR.

​
Step 6: Update the Experiment

After the PR is created, update the experiment: 
Update the "Hybrid search with re-ranking" experiment with the PR link 
https://github.com/my-org/my-repo/pull/42
Claude calls update_experiment to link the PR. If your GitHub integration is connected, the PR status will sync automatically via webhooks.

​
Step 7: Log a Decision

After the experiment runs and you have results: 
Log a decision on "Hybrid search with re-ranking": 
Ship to 100%. The re-ranker specifically helps with multi-topic queries 
where the old retriever returned tangentially related articles. 
Three retrieval experiments now, all positive. This is our best direction.
Claude calls log_decision to record the team’s decision with reasoning and timestamp.

​
Full Workflow Example

Here’s a complete Claude Code session showing the discovery-to-decision loop: 
> Show me today's research digest
  [Claude calls get_digest, shows recommended resources]

> Create an experiment from the "Query Expansion with LLMs" paper, 
  targeting resolution-rate, tagged retrieval and query-expansion, 
  in the Customer Support AI initiative
  [Claude calls create_experiment]

> Get the implementation context for that experiment
  [Claude calls get_experiment_context, shows launch context]

> Implement the technique following the implementation plan
  [Claude reads the plan, generates code, opens a PR]

> Update the experiment with the PR link and delta +2.6%, significant
  [Claude calls update_experiment]

> Log decision: Ship it. Works especially well for vague tickets 
  where the initial query has no useful search terms. 
  Retrieval direction continues to compound.
  [Claude calls log_decision]

​
Tips

When referencing experiments, use the full name or ID. Claude matches against your experiment list, but specific names avoid ambiguity.
The launch context includes an AI-generated implementation plan. Review and edit it in the experiment detail page before asking Claude Code to implement — this gives Claude better guidance.
If GitHub is connected, the PR will be automatically linked to the experiment. Status changes (merged, closed) sync via webhooks. You don’t need to manually update the PR link.

​
Next Steps

MCP Server Reference

Full MCP tool documentation

Connect Tools

Set up GitHub, Linear, and Slack integrations