Memory primitives for every
IDE, framework, and model.

npx -y @slopshop/mcp-server

{
  "mcpServers": {
    "slopshop": {
      "command": "npx",
      "args": ["-y", "@slopshop/mcp-server"],
      "env": {
        "SLOP_KEY": "YOUR_API_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "slopshop": {
      "command": "npx",
      "args": ["-y", "@slopshop/mcp-server"],
      "env": {
        "SLOP_KEY": "YOUR_API_KEY"
      }
    }
  }
}

{
  "name": "http",
  "params": {
    "url": "https://api.slopshop.gg/v1/memory/search",
    "title": "slopshop memory",
    "description": "Search persistent agent memory",
    "displayTitle": "Slopshop"
  }
}

Endpoint : https://api.slopshop.gg/v1/memory/search
Method   : GET
Header   : Authorization: Bearer YOUR_API_KEY
Param    : q={query}

from slopshop import SlopshopMemory
from langchain.chains import ConversationChain

memory = SlopshopMemory(
    api_key="YOUR_API_KEY",
    namespace="my-agent"
)

chain = ConversationChain(
    llm=llm,
    memory=memory
)

chain.run("Summarize what you know about the user")

from slopshop.llamaindex import SlopshopRetriever

retriever = SlopshopRetriever(
    api_key="YOUR_API_KEY",
    namespace="docs",
    top_k=5
)

nodes = retriever.retrieve("user preferences for UI")
for node in nodes:
    print(node.text, node.score)

from slopshop.crewai import SlopshopMemoryTool
from crewai import Agent, Task, Crew

mem_tool = SlopshopMemoryTool(api_key="YOUR_API_KEY")

researcher = Agent(
    role="Senior Researcher",
    goal="Find and retain key facts",
    tools=[mem_tool]
)

task = Task(
    description="Store findings about competitor pricing",
    agent=researcher
)

Crew(agents=[researcher], tasks=[task]).kickoff()

SLOP_BASE = "https://api.slopshop.gg/v1"
SLOP_KEY  = "YOUR_API_KEY"

# store
POST {SLOP_BASE}/memory/store
  Authorization: Bearer {SLOP_KEY}
  {"content": "...", "namespace": "autogpt"}

# search
GET {SLOP_BASE}/memory/search?q=topic&namespace=autogpt
  Authorization: Bearer {SLOP_KEY}

# dream
POST {SLOP_BASE}/memory/dream/start
  {"strategy": "synthesize,compress"}

export SLOP_KEY="your_api_key_here"

# Store
curl -s -X POST https://api.slopshop.gg/v1/memory/store \
  -H "Authorization: Bearer $SLOP_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content":"User is a senior Rust engineer. Prefers no comments."}'

# Search
curl -s "https://api.slopshop.gg/v1/memory/search?q=rust" \
  -H "Authorization: Bearer $SLOP_KEY"

npm install -g slopshop

slop memory store "User timezone is UTC-5, prefers async"
slop memory search "timezone"
slop dream run --strategy synthesize,compress
slop memory list --limit 20

# pipe any output into memory
git log --oneline -20 | slop memory store --stdin

npm install @slopshop/sdk

import { Slopshop } from "@slopshop/sdk"

const slop = new Slopshop({ apiKey: process.env.SLOP_KEY })

await slop.memory.store({
  content: "User is building a Rust CLI tool.",
  namespace: "project-alpha"
})

const results = await slop.memory.search("rust cli")
console.log(results.memories)

const dream = await slop.dream.start({
  strategy: ["synthesize", "compress", "insight_generate"]
})
console.log(dream.dream_id)

pip install slopshop

from slopshop import Slopshop

slop = Slopshop()  # reads SLOP_KEY from env

slop.memory.store(
    content="Team ships on Fridays. Deploys blocked after 4pm.",
    namespace="team-rules"
)

results = slop.memory.search("deploy rules")
for m in results["memories"]:
    print(m["content"], m["confidence"])

# async variant
import asyncio
from slopshop import AsyncSlopshop

async def main():
    async with AsyncSlopshop() as slop:
        await slop.memory.store(content="...")

asyncio.run(main())

docker run -d \
  -p 3000:3000 \
  -v slopshop-data:/data \
  -e DB_PATH=/data/slopshop.db \
  --name slopshop \
  slopshop/server:latest

git clone https://github.com/slopshop/server
cd server
npm install
node server-v2.js

# custom port
PORT=8080 node server-v2.js

# with AI handlers unlocked
ANTHROPIC_API_KEY=sk-... node server-v2.js

# No API keys set = pure local mode
# All compute handlers run in-process
# SQLite is the only persistence layer
# Dream Engine runs all 9 stages locally
# Zero telemetry. Zero callbacks home.

node server-v2.js
# → listening on http://localhost:3000