@aris-mcp/server 1.0.2 → 2.1.0

package/dist/index.js

@@ -5,500 +5,14 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z2 } from "zod";
 
-// ../core/dist/redact.js
-var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
-  "ssn",
-  "password",
-  "api_key",
-  "email",
-  "credit",
-  "secret",
-  "token",
-  "authorization"
-]);
-var EMAIL_REGEX = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
-var SSN_REGEX = /\b\d{3}-\d{2}-\d{4}\b/g;
-var PHONE_REGEX = /\b(\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g;
-function isSensitiveKey(key) {
-  const lower = key.toLowerCase();
-  for (const sensitive of SENSITIVE_KEYS) {
-    if (lower.includes(sensitive)) {
-      return true;
-    }
-  }
-  return false;
-}
-function redactStringValue(value) {
-  let result = value;
-  result = result.replace(EMAIL_REGEX, "[REDACTED_EMAIL]");
-  result = result.replace(SSN_REGEX, "[REDACTED_SSN]");
-  result = result.replace(PHONE_REGEX, "[REDACTED_PHONE]");
-  return result;
-}
-function walkAndRedact(obj) {
-  if (obj === null || obj === void 0) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => walkAndRedact(item));
-  }
-  if (typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      if (isSensitiveKey(key)) {
-        result[key] = "[REDACTED]";
-      } else if (typeof value === "string") {
-        result[key] = redactStringValue(value);
-      } else {
-        result[key] = walkAndRedact(value);
-      }
-    }
-    return result;
-  }
-  if (typeof obj === "string") {
-    return redactStringValue(obj);
-  }
-  return obj;
-}
-function redactPII(input) {
-  try {
-    const parsed = JSON.parse(input);
-    const redacted = walkAndRedact(parsed);
-    return JSON.stringify(redacted);
-  } catch {
-    return input;
-  }
-}
-
-// ../core/dist/compress.js
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "the",
-  "is",
-  "at",
-  "of",
-  "on",
-  "and",
-  "a",
-  "to",
-  "in",
-  "for",
-  "it",
-  "this",
-  "that",
-  "with",
-  "from",
-  "by",
-  "an",
-  "be",
-  "as",
-  "are",
-  "was",
-  "were",
-  "been",
-  "has",
-  "have",
-  "had",
-  "do",
-  "does",
-  "did",
-  "will",
-  "would",
-  "could",
-  "should",
-  "can",
-  "may",
-  "might"
-]);
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function extractKeywords(query) {
-  const words = query.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter((w) => w.length > 0 && !STOP_WORDS.has(w));
-  return new Set(words);
-}
-function splitSentences(text) {
-  return text.split(/(?<=[.?!])\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
-}
-function scoreSentence(sentence, keywords) {
-  const words = sentence.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/);
-  let score = 0;
-  for (const word of words) {
-    if (keywords.has(word)) {
-      score++;
-    }
-  }
-  return score;
-}
-function compressContext(query, context) {
-  const originalTokens = estimateTokens(context);
-  const keywords = extractKeywords(query);
-  let compressed;
-  if (keywords.size === 0) {
-    compressed = context.length > 500 ? context.slice(0, 500) + "..." : context;
-  } else {
-    const sentences = splitSentences(context);
-    const relevant = sentences.filter((sentence) => scoreSentence(sentence, keywords) > 0);
-    if (relevant.length === 0) {
-      compressed = context.length > 500 ? context.slice(0, 500) + "..." : context;
-    } else {
-      compressed = relevant.join(" ");
-    }
-  }
-  const compressedTokens = estimateTokens(compressed);
-  const savedTokens = originalTokens - compressedTokens;
-  const savingsPercent = originalTokens > 0 ? Math.round(savedTokens / originalTokens * 100) : 0;
-  return {
-    original: context,
-    compressed,
-    originalTokens,
-    compressedTokens,
-    savedTokens,
-    savingsPercent
-  };
-}
-
-// ../core/dist/pipeline.js
-var MAX_PROMPT_LENGTH = 1e5;
-var MAX_CONTEXT_LENGTH = 5e5;
-var DEFAULT_TIMEOUT_MS = 3e4;
-function sanitizeContext(context) {
-  let sanitized = context.replace(/<[^>]*>/g, "");
-  const injectionPatterns = [
-    /\[SYSTEM\]/gi,
-    /\[INST\]/gi,
-    /\[\/INST\]/gi,
-    /<<SYS>>/gi,
-    /<\/SYS>/gi,
-    /\[IMPORTANT\]/gi,
-    /\{system\}/gi,
-    /###\s*(?:system|instruction|admin)\s*:/gi,
-    /(?:^|\n)system\s*:\s*/gi,
-    /BEGIN SYSTEM PROMPT/gi,
-    /END SYSTEM PROMPT/gi,
-    /IGNORE PREVIOUS INSTRUCTIONS/gi,
-    /IGNORE ALL PREVIOUS/gi,
-    /YOU ARE NOW/gi,
-    /NEW INSTRUCTIONS:/gi,
-    /OVERRIDE:/gi
-  ];
-  for (const pattern of injectionPatterns) {
-    sanitized = sanitized.replace(pattern, "");
-  }
-  return sanitized;
-}
-var ArisPipeline = class {
-  llm;
-  cache;
-  enableRedaction;
-  enableCompression;
-  debug;
-  constructor(config) {
-    this.llm = config.llmProvider;
-    this.cache = config.cache;
-    this.enableRedaction = config.enableRedaction ?? true;
-    this.enableCompression = config.enableCompression ?? true;
-    this.debug = config.debug ?? false;
-  }
-  async process(query, context, options) {
-    if (query.length > MAX_PROMPT_LENGTH) {
-      throw new Error(`Prompt exceeds maximum length of ${MAX_PROMPT_LENGTH} characters (got ${query.length})`);
-    }
-    if (context && context.length > MAX_CONTEXT_LENGTH) {
-      throw new Error(`Context exceeds maximum length of ${MAX_CONTEXT_LENGTH} characters (got ${context.length})`);
-    }
-    const sanitizedContext = context ? sanitizeContext(context) : "";
-    const originalTokens = estimateTokens(query + sanitizedContext);
-    const externalSignal = options?.signal;
-    const timeoutController = new AbortController();
-    let timeoutId;
-    if (!externalSignal) {
-      timeoutId = setTimeout(() => timeoutController.abort(), DEFAULT_TIMEOUT_MS);
-    }
-    const signal = externalSignal ?? timeoutController.signal;
-    try {
-      if (signal.aborted) {
-        throw new Error("Operation aborted");
-      }
-      const cacheKey = this.cache ? `aris:pipeline:${this.cache.hashRequest(query + sanitizedContext)}` : "";
-      if (this.cache && cacheKey) {
-        const cached = await this.cache.get(cacheKey);
-        if (cached) {
-          try {
-            const parsed = JSON.parse(cached);
-            this.log("Cache hit");
-            return { ...parsed, cached: true };
-          } catch {
-          }
-        }
-      }
-      let processedQuery = query;
-      let processedContext = sanitizedContext;
-      let redacted = false;
-      if (this.enableRedaction) {
-        processedQuery = redactPII(processedQuery);
-        if (processedContext) {
-          processedContext = redactPII(processedContext);
-        }
-        redacted = true;
-        this.log("PII redaction applied");
-      }
-      let compressed = false;
-      if (this.enableCompression && processedContext) {
-        const compression = compressContext(processedQuery, processedContext);
-        processedContext = compression.compressed;
-        compressed = true;
-        this.log(`Compression: ${compression.savedTokens} tokens saved (${compression.savingsPercent}%)`);
-      }
-      const prompt = processedContext ? `Context:
-${processedContext}
-
-Query: ${processedQuery}` : processedQuery;
-      const processedTokens = estimateTokens(prompt);
-      if (signal.aborted) {
-        throw new Error("Operation aborted");
-      }
-      this.log(`Sending to ${this.llm.name}`);
-      const llmResponse = await this.llm.send(prompt, { signal });
-      const savedTokens = originalTokens - processedTokens;
-      const savingsPercent = originalTokens > 0 ? Math.round(savedTokens / originalTokens * 100) : 0;
-      const result = {
-        response: llmResponse.content,
-        model: llmResponse.model,
-        originalTokens,
-        processedTokens,
-        savedTokens,
-        savingsPercent,
-        cached: false,
-        redacted,
-        compressed,
-        usage: llmResponse.usage
-      };
-      if (this.cache && cacheKey) {
-        await this.cache.set(cacheKey, JSON.stringify(result));
-        this.log("Response cached");
-      }
-      return result;
-    } finally {
-      if (timeoutId !== void 0) {
-        clearTimeout(timeoutId);
-      }
-    }
-  }
-  log(message) {
-    if (this.debug) {
-      process.stderr.write(`[aris:pipeline] ${message}
-`);
-    }
-  }
-};
-
-// ../core/dist/providers/openrouter.js
-var DEFAULT_MODEL = "minimax/minimax-m2.5";
-var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
-var OpenRouterProvider = class {
-  name = "openrouter";
-  apiKey;
-  model;
-  baseUrl;
-  constructor(config) {
-    this.apiKey = config.apiKey;
-    this.model = config.model ?? DEFAULT_MODEL;
-    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
-  }
-  async send(prompt, options) {
-    const model = options?.model ?? this.model;
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-        "HTTP-Referer": "https://aris.dev",
-        "X-Title": "Aris MCP"
-      },
-      body: JSON.stringify({
-        model,
-        messages: [{ role: "user", content: prompt }],
-        max_tokens: options?.maxTokens ?? 4096,
-        temperature: options?.temperature ?? 0.7
-      }),
-      signal: options?.signal
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
-    }
-    const data = await response.json();
-    const content = data.choices?.[0]?.message?.content ?? "";
-    return {
-      content,
-      model: data.model ?? model,
-      usage: data.usage ? {
-        promptTokens: data.usage.prompt_tokens,
-        completionTokens: data.usage.completion_tokens,
-        totalTokens: data.usage.total_tokens
-      } : void 0
-    };
-  }
-  async healthCheck() {
-    try {
-      const response = await fetch(`${this.baseUrl}/models`, {
-        headers: { Authorization: `Bearer ${this.apiKey}` }
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// ../core/dist/providers/ollama.js
-var DEFAULT_MODEL2 = "llama3";
-var DEFAULT_BASE_URL2 = "http://localhost:11434";
-var OllamaProvider = class {
-  name = "ollama";
-  model;
-  baseUrl;
-  constructor(config = {}) {
-    this.model = config.model ?? DEFAULT_MODEL2;
-    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL2;
-  }
-  async send(prompt, options) {
-    const model = options?.model ?? this.model;
-    const response = await fetch(`${this.baseUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model,
-        messages: [{ role: "user", content: prompt }],
-        stream: false,
-        options: {
-          num_predict: options?.maxTokens ?? 4096,
-          temperature: options?.temperature ?? 0.7
-        }
-      }),
-      signal: options?.signal
-    });
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Ollama API error (${response.status}): ${errorText}`);
-    }
-    const data = await response.json();
-    const promptTokens = data.prompt_eval_count ?? 0;
-    const completionTokens = data.eval_count ?? 0;
-    return {
-      content: data.message?.content ?? "",
-      model: data.model ?? model,
-      usage: {
-        promptTokens,
-        completionTokens,
-        totalTokens: promptTokens + completionTokens
-      }
-    };
-  }
-  async healthCheck() {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/tags`);
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// ../core/dist/cache.js
-import { createHash } from "crypto";
-import { Redis } from "ioredis";
-var ArisCache = class {
-  redis;
-  constructor(redisUrl) {
-    this.redis = new Redis(redisUrl ?? "redis://localhost:6379", {
-      lazyConnect: true,
-      retryStrategy: (times) => {
-        if (times > 3)
-          return null;
-        return Math.min(times * 200, 2e3);
-      }
-    });
-    this.redis.on("error", (err) => {
-      process.stderr.write(`[ArisCache] Redis connection error: ${err.message}
-`);
-    });
-    this.redis.connect().catch((err) => {
-      process.stderr.write(`[ArisCache] Failed to connect to Redis: ${err.message}
-`);
-    });
-  }
-  async get(key) {
-    try {
-      return await this.redis.get(key);
-    } catch (err) {
-      console.warn(`[ArisCache] get failed: ${err.message}`);
-      return null;
-    }
-  }
-  async set(key, value, ttlSeconds = 600) {
-    try {
-      await this.redis.set(key, value, "EX", ttlSeconds);
-    } catch (err) {
-      console.warn(`[ArisCache] set failed: ${err.message}`);
-    }
-  }
-  hashRequest(body) {
-    return createHash("sha256").update(body).digest("hex");
-  }
-  async ping() {
-    try {
-      const result = await this.redis.ping();
-      return result === "PONG";
-    } catch {
-      return false;
-    }
-  }
-  async checkThrottle(maxJoules = 5e3) {
-    try {
-      const value = await this.redis.get("aris_system_joules");
-      if (value === null)
-        return false;
-      const joules = parseFloat(value);
-      return joules > maxJoules;
-    } catch (err) {
-      console.warn(`[ArisCache] checkThrottle failed: ${err.message}`);
-      return false;
-    }
-  }
-  async disconnect() {
-    try {
-      await this.redis.quit();
-    } catch {
-    }
-  }
-};
-
 // src/config.ts
-function envBool(value, defaultValue) {
-  if (value === void 0) return defaultValue;
-  return value.toLowerCase() === "true";
-}
 function loadConfig() {
-  const llmProvider = process.env.ARIS_LLM_PROVIDER ?? "openrouter";
-  const llmApiKey = process.env.ARIS_API_KEY;
-  const ollamaUrl = process.env.ARIS_OLLAMA_URL ?? "http://localhost:11434";
-  if (llmProvider === "openrouter" && !llmApiKey) {
-    throw new Error(
-      "ARIS_API_KEY is required when ARIS_LLM_PROVIDER is 'openrouter'"
-    );
+  const apiKey = process.env.ARIS_API_KEY;
+  if (!apiKey) {
+    throw new Error("ARIS_API_KEY is required");
   }
-  return {
-    endpoint: process.env.ARIS_ENDPOINT,
-    llmProvider,
-    llmApiKey,
-    llmModel: process.env.ARIS_LLM_MODEL,
-    ollamaUrl,
-    redisUrl: process.env.ARIS_REDIS_URL,
-    enableRedaction: envBool(process.env.ARIS_ENABLE_REDACTION, true),
-    enableCompression: envBool(process.env.ARIS_ENABLE_COMPRESSION, true),
-    debug: envBool(process.env.ARIS_DEBUG, false)
-  };
+  const apiUrl = process.env.ARIS_API_URL ?? "https://energetic-light-production.up.railway.app";
+  return { apiKey, apiUrl };
 }
 
 // src/tools.ts
@@ -581,24 +95,183 @@ var TOOL_DEFINITIONS = [
   }
 ];
 
+// src/setup.ts
+import { createInterface } from "readline/promises";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var RESET = "\x1B[0m";
+var MCP_CONFIG = (apiKey) => ({
+  aris: {
+    command: "npx",
+    args: ["-y", "@aris-mcp/server"],
+    env: {
+      ARIS_API_KEY: apiKey
+    }
+  }
+});
+function getIdeTargets() {
+  const home = homedir();
+  return [
+    {
+      name: "Claude Code",
+      configPath: join(home, ".claude", "settings.json"),
+      configKey: "mcpServers"
+    },
+    {
+      name: "Cursor",
+      configPath: join(home, ".cursor", "mcp.json"),
+      configKey: "mcpServers"
+    },
+    {
+      name: "VS Code",
+      configPath: join(home, ".vscode", "mcp.json"),
+      configKey: "servers"
+    },
+    {
+      name: "Windsurf",
+      configPath: join(home, ".codeium", "windsurf", "mcp_config.json"),
+      configKey: "mcpServers"
+    }
+  ];
+}
+function detectInstalledIdes() {
+  const targets = getIdeTargets();
+  const home = homedir();
+  return targets.filter((ide) => {
+    if (existsSync(ide.configPath)) return true;
+    const dir = ide.configPath.substring(0, ide.configPath.lastIndexOf("/"));
+    if (existsSync(dir)) return true;
+    if (process.platform === "darwin") {
+      const appNames = {
+        "Claude Code": [],
+        // CLI-based, check for .claude dir
+        "Cursor": ["/Applications/Cursor.app"],
+        "VS Code": ["/Applications/Visual Studio Code.app"],
+        "Windsurf": ["/Applications/Windsurf.app"]
+      };
+      const paths = appNames[ide.name] ?? [];
+      return paths.some((p) => existsSync(p));
+    }
+    return false;
+  });
+}
+function readJsonFile(path) {
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function writeJsonFile(path, data) {
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function configureIde(ide, apiKey) {
+  try {
+    const config = readJsonFile(ide.configPath);
+    const servers = config[ide.configKey] ?? {};
+    if (servers.aris) {
+      const existing = servers.aris;
+      const env = existing.env ?? {};
+      env.ARIS_API_KEY = apiKey;
+      existing.env = env;
+    } else {
+      servers.aris = MCP_CONFIG(apiKey).aris;
+    }
+    config[ide.configKey] = servers;
+    writeJsonFile(ide.configPath, config);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runSetup() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  console.log("");
+  console.log(`  ${BOLD}Aris MCP Server${RESET} ${DIM}v2.0.0${RESET}`);
+  console.log(`  ${DIM}Optimize every LLM call${RESET}`);
+  console.log("");
+  console.log(`  ${CYAN}Step 1${RESET} ${DIM}/${RESET} API Key`);
+  console.log(`  ${DIM}Get yours at https://aris.dev${RESET}`);
+  console.log("");
+  const apiKey = await rl.question(`  ${BOLD}ARIS_API_KEY:${RESET} `);
+  if (!apiKey.trim()) {
+    console.log(`
+  ${RED}No API key provided. Exiting.${RESET}
+`);
+    rl.close();
+    process.exit(1);
+  }
+  console.log("");
+  console.log(`  ${CYAN}Step 2${RESET} ${DIM}/${RESET} Detecting IDEs...`);
+  console.log("");
+  const detected = detectInstalledIdes();
+  if (detected.length === 0) {
+    console.log(`  ${YELLOW}No supported IDEs detected.${RESET}`);
+    console.log("");
+    console.log(`  ${DIM}Manually add to your MCP config:${RESET}`);
+    console.log("");
+    console.log(`  ${DIM}${JSON.stringify({ mcpServers: MCP_CONFIG(apiKey.trim()) }, null, 2).split("\n").join("\n  ")}${RESET}`);
+    console.log("");
+    rl.close();
+    return;
+  }
+  for (const ide of detected) {
+    console.log(`  ${GREEN}found${RESET}  ${ide.name} ${DIM}${ide.configPath}${RESET}`);
+  }
+  console.log("");
+  const answer = await rl.question(`  ${BOLD}Configure ${detected.length} IDE${detected.length > 1 ? "s" : ""}? [Y/n]${RESET} `);
+  if (answer.trim().toLowerCase() === "n") {
+    console.log(`
+  ${DIM}Skipped. Add ARIS_API_KEY to your MCP config manually.${RESET}
+`);
+    rl.close();
+    return;
+  }
+  console.log("");
+  let configured = 0;
+  for (const ide of detected) {
+    const ok = configureIde(ide, apiKey.trim());
+    if (ok) {
+      console.log(`  ${GREEN}done${RESET}   ${ide.name}`);
+      configured++;
+    } else {
+      console.log(`  ${RED}fail${RESET}   ${ide.name} ${DIM}(check permissions)${RESET}`);
+    }
+  }
+  console.log("");
+  if (configured > 0) {
+    console.log(`  ${GREEN}${BOLD}Aris configured in ${configured} IDE${configured > 1 ? "s" : ""}.${RESET}`);
+    console.log(`  ${DIM}Restart your IDE to activate.${RESET}`);
+    console.log("");
+    console.log(`  ${DIM}Tools available:${RESET}`);
+    console.log(`    ${CYAN}aris_optimize${RESET}  ${DIM}Full pipeline: redact + compress + LLM${RESET}`);
+    console.log(`    ${CYAN}aris_compress${RESET}  ${DIM}Context compression only${RESET}`);
+    console.log(`    ${CYAN}aris_health${RESET}    ${DIM}Check pipeline status${RESET}`);
+  }
+  console.log("");
+  rl.close();
+}
+
 // src/index.ts
 function log(message) {
   process.stderr.write(`[aris-mcp] ${message}
 `);
 }
-function createLLMProvider(config) {
-  if (config.llmProvider === "ollama") {
-    return new OllamaProvider({
-      baseUrl: config.ollamaUrl,
-      model: config.llmModel
-    });
-  }
-  return new OpenRouterProvider({
-    apiKey: config.llmApiKey,
-    model: config.llmModel
-  });
-}
 async function main() {
+  if (!process.env.ARIS_API_KEY && process.stdin.isTTY) {
+    await runSetup();
+    return;
+  }
   let config;
   try {
     config = loadConfig();
@@ -606,111 +279,67 @@ async function main() {
     log(`Configuration error: ${err.message}`);
     process.exit(1);
   }
-  log(`Provider: ${config.llmProvider}`);
-  log(`Redaction: ${config.enableRedaction ? "enabled" : "disabled"}`);
-  log(`Compression: ${config.enableCompression ? "enabled" : "disabled"}`);
-  log(`Cache: ${config.redisUrl ? "enabled" : "disabled"}`);
-  const llmProvider = createLLMProvider(config);
-  let cache;
-  if (config.redisUrl) {
-    cache = new ArisCache(config.redisUrl);
-    log("Redis cache initialized");
+  log(`API: ${config.apiUrl}`);
+  async function apiCall(path, body) {
+    const res = await fetch(`${config.apiUrl}${path}`, {
+      method: body ? "POST" : "GET",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: body ? JSON.stringify(body) : void 0,
+      signal: AbortSignal.timeout(35e3)
+    });
+    const data = await res.json();
+    return { status: res.status, data };
   }
-  const pipeline = new ArisPipeline({
-    llmProvider,
-    cache,
-    enableRedaction: config.enableRedaction,
-    enableCompression: config.enableCompression,
-    debug: config.debug
-  });
   const server = new McpServer(
-    {
-      name: "aris-mcp",
-      version: "1.0.0"
-    },
-    {
-      capabilities: {
-        tools: {}
-      }
-    }
+    { name: "aris-mcp", version: "2.0.0" },
+    { capabilities: { tools: {} } }
   );
   server.tool(
     ToolName.OPTIMIZE,
     TOOL_DESCRIPTIONS[ToolName.OPTIMIZE],
     {
-      prompt: z2.string().min(1, "Prompt must not be empty").max(1e5, "Prompt must be under 100,000 characters").describe(
-        "The user prompt to optimize and send through the Aris pipeline. This is the main instruction or question for the LLM."
+      prompt: z2.string().min(1).max(1e5).describe(
+        "The user prompt to optimize and send through the Aris pipeline."
       ),
-      context: z2.string().max(5e5, "Context must be under 500,000 characters").optional().describe(
-        "Optional background context to compress before including with the prompt. Long documents, code snippets, or reference material that will be filtered to only the sentences relevant to the prompt."
+      context: z2.string().max(5e5).optional().describe(
+        "Optional background context to compress before including with the prompt."
       )
     },
-    async ({ prompt, context }, { sendNotification }) => {
+    async ({ prompt, context }) => {
       try {
-        await sendNotification({
-          method: "notifications/progress",
-          params: {
-            progressToken: "aris_optimize",
-            progress: 0,
-            total: 100,
-            message: "Starting Aris optimization pipeline..."
-          }
-        });
-        await sendNotification({
-          method: "notifications/progress",
-          params: {
-            progressToken: "aris_optimize",
-            progress: 20,
-            total: 100,
-            message: "Applying PII redaction and context compression..."
-          }
-        });
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 3e4);
-        let result;
-        try {
-          result = await pipeline.process(prompt, context, {
-            signal: controller.signal
-          });
-        } finally {
-          clearTimeout(timeout);
+        const { status, data } = await apiCall("/optimize", { prompt, context });
+        if (status !== 200) {
+          return {
+            content: [{ type: "text", text: `Pipeline error: ${data.error ?? "Unknown error"}` }],
+            isError: true
+          };
         }
-        await sendNotification({
-          method: "notifications/progress",
-          params: {
-            progressToken: "aris_optimize",
-            progress: 100,
-            total: 100,
-            message: "Pipeline complete."
-          }
-        });
         const summary = [
-          result.response,
+          data.response,
           "",
           "--- Aris Pipeline Stats ---",
-          `Model: ${result.model}`,
-          `Original tokens: ${result.originalTokens}`,
-          `Processed tokens: ${result.processedTokens}`,
-          `Tokens saved: ${result.savedTokens} (${result.savingsPercent}%)`,
-          `Cached: ${result.cached}`,
-          `Redacted: ${result.redacted}`,
-          `Compressed: ${result.compressed}`
+          `Model: ${data.model}`,
+          `Original tokens: ${data.originalTokens}`,
+          `Processed tokens: ${data.processedTokens}`,
+          `Tokens saved: ${data.savedTokens} (${data.savingsPercent}%)`,
+          `Cached: ${data.cached}`,
+          `Redacted: ${data.redacted}`,
+          `Compressed: ${data.compressed}`
         ];
-        if (result.usage) {
+        const usage = data.usage;
+        if (usage) {
           summary.push(
-            `LLM usage - prompt: ${result.usage.promptTokens}, completion: ${result.usage.completionTokens}, total: ${result.usage.totalTokens}`
+            `LLM usage - prompt: ${usage.promptTokens}, completion: ${usage.completionTokens}, total: ${usage.totalTokens}`
           );
         }
-        return {
-          content: [{ type: "text", text: summary.join("\n") }]
-        };
+        return { content: [{ type: "text", text: summary.join("\n") }] };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        const errorText = message.includes("aborted") ? "Pipeline timed out after 30 seconds" : `Pipeline error: ${message}`;
-        return {
-          content: [{ type: "text", text: errorText }],
-          isError: true
-        };
+        const errorText = message.includes("TimeoutError") || message.includes("aborted") ? "Pipeline timed out" : message.includes("fetch") ? "Aris API unavailable" : `Pipeline error: ${message}`;
+        return { content: [{ type: "text", text: errorText }], isError: true };
       }
     }
   );
@@ -720,42 +349,18 @@ async function main() {
     {},
     async () => {
       try {
-        const llmHealthy = await llmProvider.healthCheck();
-        const cacheHealthy = cache ? await cache.ping() : null;
-        const status = {
-          llm: {
-            provider: config.llmProvider,
-            model: config.llmModel ?? "(default)",
-            healthy: llmHealthy
-          },
-          cache: {
-            enabled: !!cache,
-            healthy: cacheHealthy,
-            url: config.redisUrl ? "(configured)" : "(not configured)"
-          },
-          features: {
-            redaction: config.enableRedaction,
-            compression: config.enableCompression
-          },
-          debug: config.debug
-        };
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(status, null, 2)
-            }
-          ]
-        };
+        const { status, data } = await apiCall("/health");
+        if (status !== 200) {
+          return {
+            content: [{ type: "text", text: `Health check error: ${data.error ?? "Unknown error"}` }],
+            isError: true
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return {
-          content: [
-            {
-              type: "text",
-              text: `Health check error: ${message}`
-            }
-          ],
+          content: [{ type: "text", text: `Health check error: ${message}` }],
           isError: true
         };
       }
@@ -765,37 +370,36 @@ async function main() {
     ToolName.COMPRESS,
     TOOL_DESCRIPTIONS[ToolName.COMPRESS],
     {
-      query: z2.string().min(1, "Query must not be empty").max(1e5, "Query must be under 100,000 characters").describe(
-        "The query used to determine which sentences in the context are relevant. Only sentences matching keywords from this query are retained."
+      query: z2.string().min(1).max(1e5).describe(
+        "The query used to determine which sentences in the context are relevant."
       ),
-      context: z2.string().min(1, "Context must not be empty").max(5e5, "Context must be under 500,000 characters").describe(
-        "The context text to compress. Sentences not relevant to the query will be removed to reduce token usage."
+      context: z2.string().min(1).max(5e5).describe(
+        "The context text to compress."
       )
     },
     async ({ query, context }) => {
       try {
-        const result = compressContext(query, context);
+        const { status, data } = await apiCall("/compress", { query, context });
+        if (status !== 200) {
+          return {
+            content: [{ type: "text", text: `Compression error: ${data.error ?? "Unknown error"}` }],
+            isError: true
+          };
+        }
         const summary = [
           "Compressed context:",
-          result.compressed,
+          data.compressed,
           "",
           "--- Compression Stats ---",
-          `Original tokens: ${result.originalTokens}`,
-          `Compressed tokens: ${result.compressedTokens}`,
-          `Tokens saved: ${result.savedTokens} (${result.savingsPercent}%)`
+          `Original tokens: ${data.originalTokens}`,
+          `Compressed tokens: ${data.compressedTokens}`,
+          `Tokens saved: ${data.savedTokens} (${data.savingsPercent}%)`
         ];
-        return {
-          content: [{ type: "text", text: summary.join("\n") }]
-        };
+        return { content: [{ type: "text", text: summary.join("\n") }] };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return {
-          content: [
-            {
-              type: "text",
-              text: `Compression error: ${message}`
-            }
-          ],
+          content: [{ type: "text", text: `Compression error: ${message}` }],
           isError: true
         };
       }
@@ -807,12 +411,8 @@ async function main() {
   const shutdown = async () => {
     log("Shutting down...");
     try {
-      if (cache) {
-        await cache.disconnect();
-      }
       await server.close();
-    } catch (err) {
-      log(`Error during shutdown: ${err.message}`);
+    } catch {
     }
     process.exit(0);
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aris-mcp/server",
-  "version": "1.0.2",
+  "version": "2.1.0",
   "type": "module",
   "bin": {
     "aris-mcp": "dist/index.js"
@@ -31,7 +31,6 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "ioredis": "^5.6.1",
     "zod": "^3.24.4"
   },
   "devDependencies": {