Slopshop for
Claude & Anthropic Agents

// Self-host the Slopshop MCP server alongside Claude Code
// node mcp-server.js — exposes the full catalog of tools over stdio MCP protocol

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server({ name: 'slopshop', version: '1.0.0' });
const BASE = 'https://slopshop.gg';
const KEY  = process.env.SLOPSHOP_API_KEY;

// Fetch the full tool manifest from Slopshop
const manifest = await fetch(`${BASE}/v1/mcp/tools`, {
  headers: { 'Authorization': `Bearer ${KEY}` }
}).then(r => r.json());

server.setRequestHandler('tools/list', () => ({ tools: manifest.tools }));

server.setRequestHandler('tools/call', async ({ name, arguments: args }) => {
  const res = await fetch(`${BASE}/v1/${name}`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(args)
  });
  return { content: [{ type: 'text', text: JSON.stringify(await res.json()) }] };
});

await server.connect(new StdioServerTransport());

import Anthropic from '@anthropic-ai/sdk';

const claude   = new Anthropic();
const SLOP_KEY = process.env.SLOPSHOP_API_KEY;
const SLOP_URL = 'https://slopshop.gg';

// 1. Pull Slopshop tools as Anthropic tool definitions
async function getSlopshopTools(slugs = []) {
  const url = slugs.length
    ? `${SLOP_URL}/v1/mcp/recommended?tools=${slugs.join(',')}`
    : `${SLOP_URL}/v1/mcp/recommended`;
  const data = await fetch(url, {
    headers: { 'Authorization': `Bearer ${SLOP_KEY}` }
  }).then(r => r.json());

  // Each tool is already in Anthropic's tool format
  return data.tools; // [{ name, description, input_schema }]
}

// 2. Execute a tool call via Slopshop
async function executeTool(toolName, toolInput) {
  const res = await fetch(`${SLOP_URL}/v1/${toolName}`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${SLOP_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(toolInput)
  });
  return res.json();
}

// 3. Agentic loop — Claude calls tools, Slopshop executes
async function runAgent(userMessage) {
  const tools = await getSlopshopTools([
    'dns-lookup', 'ssl-check', 'http-request',
    'whois', 'hash', 'memory-set'
  ]);

  let messages = [{ role: 'user', content: userMessage }];

  while (true) {
    const response = await claude.messages.create({
      model: 'claude-opus-4-6',
      max_tokens: 4096,
      tools,
      messages
    });

    if (response.stop_reason === 'end_turn') {
      return response.content.find(b => b.type === 'text')?.text;
    }

    if (response.stop_reason === 'tool_use') {
      messages.push({ role: 'assistant', content: response.content });

      // Execute all tool calls in parallel
      const toolResults = await Promise.all(
        response.content
          .filter(b => b.type === 'tool_use')
          .map(async block => {
            const result = await executeTool(block.name, block.input);
            return {
              type: 'tool_result',
              tool_use_id: block.id,
              content: JSON.stringify(result)
            };
          })
      );

      messages.push({ role: 'user', content: toolResults });
    }
  }
}

// Run it
const answer = await runAgent(
  'Audit slopshop.gg — check DNS, SSL cert, HTTP headers, and save results to memory'
);
console.log(answer);