# io.github.Whatsonyourmind/oraclaw (npm · @oraclaw/mcp-server)

Decision intelligence MCP — 17 tools (optimize, simulate, predict, score, graph). Sub-25ms.

- Trust score: 66/100 (medium)
- Change this week: +24
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-04

## Components

- npm · `@oraclaw/mcp-server`: 66/100 (this document), [markdown](https://verifymcp.io/servers/whatsonyourmind-oraclaw/oraclaw-mcp-server.md), [page](https://verifymcp.io/servers/whatsonyourmind-oraclaw/oraclaw-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `@oraclaw/mcp-server`
- Version: `1.5.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-04.

- **Supply Chain Security**: 83/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known medium-severity CVE affects hono 4.12.33, reached via @modelcontextprotocol/sdk > hono. A fixed version is available.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (94 of 98), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 41 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 65/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 3215 tokens (~189/item across 17 items; 17 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 30/100
  - Stability observed for 9 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 95/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 83% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add whatsonyourmind-oraclaw -- npx -y @oraclaw/mcp-server
```

### Codex

```bash
codex mcp add whatsonyourmind-oraclaw -- npx -y @oraclaw/mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "whatsonyourmind-oraclaw": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@oraclaw/mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add whatsonyourmind-oraclaw --command npx --arg -y --arg @oraclaw/mcp-server
```

### Hermes

```yaml
mcp_servers:
  whatsonyourmind-oraclaw:
    command: "npx"
    args: ["-y", "@oraclaw/mcp-server"]
```

### Other

```json
{
  "mcpServers": {
    "whatsonyourmind-oraclaw": {
      "command": "npx",
      "args": [
        "-y",
        "@oraclaw/mcp-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-04 (score 66, +4)

- [security regression] CVE-2026-69207 affects this package: medium
- [security regression] Known CVEs: partial → fail
- [functional improvement] Stability: unverified → 0.30

### 2026-08-02 (score 62, +44)

- [security regression] Provenance: unverified → fail
- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Schema quality: unverified → excellent
- [functional improvement] License: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional] Licence: MIT

### 2026-08-01 (score 18, −6)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-31 (score 24, −18)

- [security regression] Malware scan: pass → unverified
- [functional regression] Security disclosure: unverified → fail

### 2026-07-29 (score 42, 0)

- [functional regression] Security disclosure: fail → unverified

### 2026-07-27 (score 42)

First indexed and scored.

## MCP tools (17)

### `optimize_bandit` (~159 tokens)

Select the next option to try from 2+ variants that each have observed pull/reward history, balancing exploitation against exploration (UCB1, Thompson sampling, or epsilon-greedy). Use when you must pick one arm now from A/B test variants, ad/email/copy options, or ranked recommendations and have past trial counts. Returns the chosen arm plus exploitation score, exploration bonus, and a regret estimate. For per-call context features use optimize_contextual; for continuous parameters use optimize_cmaes.

Input parameters:

- `algorithm` (string): Selection algorithm (default: ucb1). UCB1 is deterministic; thompson/epsilon-greedy sample.
- `arms` (array, required): Candidate options to choose between (at least 2).

Output parameters:

- `algorithm` (string): Which algorithm produced the selection.
- `exploitation` (number): Pure mean-reward component.
- `exploration` (number): Uncertainty bonus added to exploitation.
- `regret` (number): Cumulative regret estimate (lower is better).
- `score` (number): Combined exploitation + exploration score.
- `selected` (object): The chosen arm.

### `optimize_contextual` (~156 tokens)

Select the best option given a numeric context/feature vector, using a LinUCB contextual bandit that learns per-context preferences from optional history. Use when the best choice changes with situational features that vary call-to-call (user/segment attributes, time of day, current regime). Returns the chosen arm with its LinUCB expected reward and confidence width. If you have no per-call features, use optimize_bandit.

Input parameters:

- `alpha` (number): Exploration coefficient (default: 1.0). Higher = more exploration.
- `arms` (array, required)
- `context` (array, required): Numeric feature vector describing the current situation. Length must match across calls.
- `history` (array): Optional past observations to seed the model.

Output parameters:

- `algorithm` (string)
- `confidenceWidth` (number): Uncertainty bound on the estimate.
- `expectedReward` (number): LinUCB point estimate of reward.
- `score` (number): expectedReward + alpha * confidenceWidth.
- `selected` (object)

### `optimize_cmaes` (~216 tokens)

[Premium] Optimize N continuous parameters against a weighted-sum objective using CMA-ES, suited to non-convex/noisy/gradient-free landscapes. Use for hyperparameter search, simulator calibration, or control-policy tuning where you supply per-dimension objective weights. Returns the best parameter vector, its objective value, iteration/evaluation counts, and a converged flag; stochastic init means repeated runs may differ. Use optimize_evolve for discrete spaces and solve_constraints for linear/MIP constraints. Premium: needs an ORACLAW_API_KEY OR a per-call x402 payment (no signup).

Input parameters:

- `dimension` (integer, required): Number of parameters to optimize.
- `initialMean` (array): Optional starting point in parameter space.
- `initialSigma` (number): Initial step size (default: 0.5).
- `maxIterations` (integer): Max generations (default: 1000, capped at 5000).
- `objectiveWeights` (array, required): Per-dimension weight in the linear default objective. Length must equal dimension.

Output parameters:

- `bestFitness` (number): Objective value at bestSolution (caller's sign convention).
- `bestSolution` (array): Best parameter vector found.
- `converged` (boolean): Whether convergence criteria were met before maxIterations.
- `evaluations` (integer): Total objective evaluations.
- `executionTimeMs` (number)
- `iterations` (integer): Generations actually run.

### `solve_constraints` (~170 tokens)

[Premium] Solve a linear / mixed-integer / quadratic program with the HiGHS solver and return a provably optimal assignment. Use when your objective and constraints are linear (or quadratic) over named continuous/integer/binary variables: budget allocation, supply or capacity planning with integer counts, allocation with hard caps. Returns solver status (optimal/infeasible/unbounded), the objective value, and the solved value per variable. Use optimize_cmaes for black-box objectives and solve_schedule for task-to-slot assignment. Premium: needs an ORACLAW_API_KEY OR a per-call x402 payment (no signup).

Input parameters:

- `constraints` (array, required)
- `direction` (string, required)
- `objective` (object, required): Map of variable name → coefficient in the objective function.
- `variables` (array, required)

Output parameters:

- `certificate` (object): Re-checkable result certificate: verify the answer without trusting the solver. Recompute feasibility + objective from `solution`, check `contentHash` binds them, and (for LPs) check the KKT duality…
- `objectiveValue` (number): Objective at the optimum (when status='optimal').
- `solution` (object): Map of variable name → solved value.
- `solveTimeMs` (number)
- `status` (string): e.g. 'optimal', 'infeasible', 'unbounded'.

### `solve_schedule` (~107 tokens)

Assign tasks to time slots to maximize total score by matching each task's energy requirement to a slot's energy level (and respecting duration). Use for deep-work blocking, shift or session planning, or any task-to-slot fit where high-energy work should land in high-energy slots. Returns the assignments, any unassigned task IDs, and a total score. For arbitrary linear constraints use solve_constraints; for routing use plan_pathfind.

Input parameters:

- `slots` (array, required)
- `tasks` (array, required)

Output parameters:

- `assignments` (array)
- `totalScore` (number)
- `unassignedTasks` (array): Task IDs that did not fit.

### `analyze_graph` (~182 tokens)

[Premium] Compute structural metrics of a directed weighted graph: PageRank centrality, Louvain community clusters, an optional critical path between two given nodes, and bottleneck nodes. Use to find the most influential nodes, cluster a dependency/knowledge graph, or locate chokepoints in supply or process networks. Returns per-node PageRank and community index, cluster summaries, the critical path with its weight, and bottlenecks. For a single source-to-goal route, use plan_pathfind (free). Premium: needs an ORACLAW_API_KEY OR a per-call x402 payment (no signup).

Input parameters:

- `edges` (array, required)
- `nodes` (array, required)
- `sourceGoal` (string): Optional: node ID to use as start of critical path.
- `targetGoal` (string): Optional: node ID to use as end of critical path.

Output parameters:

- `bottlenecks` (array): Nodes whose removal most disconnects the graph.
- `clusters` (array)
- `communities` (object): Node ID → community index.
- `criticalPath` (array): Node IDs from sourceGoal to targetGoal.
- `criticalPathWeight` (number)
- `pageRank` (object): Node ID → PageRank score.
- `totalNodes` (integer)

### `analyze_risk` (~294 tokens)

[Premium] Compute portfolio Value-at-Risk and Conditional VaR (Expected Shortfall) from a historical [asset][time] return matrix and portfolio weights, accounting for cross-asset correlation. Use to size downside risk on a weighted multi-asset book, attribute risk, or run drawdown scenarios with auditable inputs. Returns VaR and CVaR (loss as a positive number) at the requested confidence, plus expected return, volatility, and the horizon used. To sample outcomes from a parametric distribution instead, use simulate_montecarlo. Premium: needs an ORACLAW_API_KEY OR a per-call x402 payment (no signup).

Input parameters:

- `ciLevel` (number): Two-sided confidence level for the estimation-error CIs in the certificate (default: 0.95).
- `confidence` (number): VaR confidence level (default: 0.95).
- `horizonDays` (integer): Horizon in days, scales VaR by sqrt(horizon) (default: 1).
- `realizedExceedances` (array): Optional backtest hit sequence (1 = VaR breach); enables a Kupiec unconditional-coverage test in the certificate.
- `returns` (array, required): [asset][time] matrix of period returns (e.g. daily). Each row same length.
- `weights` (array, required): Portfolio weights per asset. Length must equal returns.length. Should sum to 1.

Output parameters:

- `assets` (integer)
- `certificate` (object): Re-checkable estimation-error certificate: delta-method SE/CI for VaR and ES under the iid-normal assumption, esStatisticallyDistinctFromVaR, effectiveSampleSupport (the estimation window T), an opti…
- `confidence` (number)
- `cvar` (number): Conditional VaR (mean loss beyond VaR threshold).
- `expectedReturn` (number)
- `horizonDays` (integer)
- `var` (number): Value-at-Risk at the requested confidence (loss expressed as positive number).
- `volatility` (number)

### `score_convergence` (~135 tokens)

Score how strongly multiple independent sources agree on a single event's probability, using Hellinger-distance agreement plus penalties for dispersion/uncertainty and a freshness weight (recency, source volume, and confidence). Use to fuse 0..1 estimates from polls, prediction markets, or model outputs into one number. Returns a 0..1 convergence score, the volume-weighted consensus probability, source count, and component breakdown. To combine N point predictions instead, use predict_ensemble.

Input parameters:

- `config` (object): Optional weighting overrides.
- `sources` (array, required): Independent estimators each emitting a probability for the same event.

Output parameters:

- `components` (object): Per-component scores feeding the aggregate.
- `consensusProbability` (number): Weighted aggregate probability.
- `convergenceScore` (number): Overall agreement (1=consensus, 0=divergent).
- `sources` (integer): Number of sources used.

### `predict_forecast` (~216 tokens)

[Premium] Forecast the next N values of one evenly-spaced numeric time series using ARIMA (non-seasonal trend) or Holt-Winters (additive seasonal, set seasonLength). Use for short-to-medium horizon point forecasts of demand, KPIs, or capacity. Returns the point forecast array plus lower/upper confidence bands and the fitted model description. ARIMA requires at least 20 observations; Holt-Winters needs at least 2 x seasonLength. To flag outliers instead of projecting, use detect_anomaly. Premium: needs an ORACLAW_API_KEY OR a per-call x402 payment (no signup).

Input parameters:

- `data` (array, required): Historical values, evenly spaced. ARIMA needs ≥20 points; Holt-Winters needs ≥2 × seasonLength.
- `method` (string): Default: arima.
- `seasonLength` (integer): Period of seasonality (only used by holt-winters). Default: 4.
- `steps` (integer, required): Number of future periods to forecast.

Output parameters:

- `confidence` (object)
- `forecast` (array): Point forecasts, length = steps.
- `inputLength` (integer)
- `method` (string)
- `model` (string): Fitted model description.
- `steps` (integer)

### `detect_anomaly` (~196 tokens)

[Premium] Flag outlier points in a numeric series using a Z-score test (parametric, assumes near-normal) or IQR test (robust to skew/heavy tails). Use for metric monitoring, fraud/abuse signals, sensor noise, or quality control. Returns each anomaly's index, value, and score, plus the underlying statistics (mean/stdDev/threshold for Z-score; q1/q3/IQR/bounds for IQR) and an anomaly count. To project a series forward instead, use predict_forecast. Premium: needs an ORACLAW_API_KEY OR a per-call x402 payment (no signup).

Input parameters:

- `data` (array, required): Numeric series to scan.
- `method` (string): Default: zscore.
- `threshold` (number): Z-score: standard deviations above mean (default: 3.0). IQR: multiplier on IQR (default: 1.5).

Output parameters:

- `anomalies` (array)
- `anomalyCount` (integer)
- `method` (string)
- `stats` (object): For zscore: {mean, stdDev, threshold}. For iqr: {q1, q3, iqr, lowerBound, upperBound}.
- `totalPoints` (integer)

### `plan_pathfind` (~203 tokens)

Find the shortest path (or k-shortest paths) between a start and end node in a weighted directed graph using A* with selectable heuristic (zero=Dijkstra, time, cost, risk, weighted) and Yen's algorithm for alternatives. Use for routing, dependency resolution, or 'how do I get from X to Y' over a graph; set kPaths>1 for alternatives. Returns the path node IDs, total cost, a time/cost/risk breakdown, nodes explored, and a found flag. For centrality/communities use analyze_graph; for task-to-slot assignment use solve_schedule.

Input parameters:

- `edges` (array, required)
- `end` (string, required): Goal node ID.
- `heuristic` (string): A* heuristic. 'zero' = Dijkstra (default).
- `kPaths` (integer): Return up to k alternative paths (default: 1).
- `nodes` (array, required)
- `start` (string, required): Start node ID.

Output parameters:

- `alternativePaths` (array): Only present when kPaths > 1.
- `breakdown` (object)
- `executionTimeMs` (number)
- `found` (boolean): False if no path exists.
- `nodesExplored` (integer)
- `path` (array): Node IDs from start to end.
- `totalCost` (number)

### `simulate_montecarlo` (~297 tokens)

Draw N samples from one parametric distribution (normal, lognormal, uniform, triangular, beta, or exponential) and summarize the resulting spread. Use to quantify uncertainty around a single random factor: an NPV under an uncertain growth rate, a latency tail, or a reserve estimate. Returns the mean, standard deviation, p5/p25/p50/p75/p95 percentiles, a histogram, and the iteration count; each call re-samples (non-deterministic) and is capped at 2000 iterations. For correlated multi-asset risk, use analyze_risk.

Input parameters:

- `confidenceLevel` (number): Two-sided confidence level for the MCSE intervals (default 0.95).
- `distribution` (string, required): Distribution family to sample from.
- `params` (object, required): Distribution parameters. Required keys depend on distribution: normal/lognormal={mean,stddev}, uniform={min,max}, triangular={min,mode,max}, beta={alpha,beta}, exponential={lambda}.
- `seed` (integer): Optional integer seed for a reproducible run; recorded in the certificate so anyone can re-derive the same draws.
- `simulations` (integer): Number of samples (default: 1000, max: 2000 free).
- `targetHalfWidth` (number): Optional ABSOLUTE precision target for the mean's CI half-width; the certificate reports replicationAdequacy = (meanHalfWidth <= this).

Output parameters:

- `certificate` (object): Re-checkable precision certificate: MCSE of the mean (analytic + batch-means), bootstrap MCSE per percentile, replicationAdequacy vs targetHalfWidth, the resolved seed, and a sha256 contentHash bindi…
- `executionTimeMs` (number)
- `histogram` (array): Bucketed counts.
- `iterations` (integer)
- `mean` (number)
- `percentiles` (object)
- `stdDev` (number)
- `timedOut` (boolean)

### `score_calibration` (~146 tokens)

Measure how well a set of probability predictions matched observed binary outcomes, returning the Brier score and log score (lower is better). Use to evaluate a forecaster's or model's calibration: predictions[i] is the probability assigned to event i and outcomes[i] is 1 if it occurred, else 0 (arrays must be equal length). Returns brier_score, log_score, the number of predictions, and the mean predicted vs mean observed rate. To measure agreement across multiple sources instead, use score_convergence.

Input parameters:

- `outcomes` (array, required): Binary realised outcomes. Must be the same length as predictions.
- `predictions` (array, required): Predicted probabilities in [0,1].

Output parameters:

- `brier_score` (number): Mean squared error between probability and outcome (lower is better).
- `log_score` (number): Negative log-likelihood (lower is better; -inf possible if a 0-prob event happens).
- `mean_outcome` (number)
- `mean_prediction` (number)
- `n_predictions` (integer)

### `predict_bayesian` (~167 tokens)

Update a prior probability with weighted evidence signals using a Beta posterior (the prior seeds Beta(prior*10, (1-prior)*10)). Use for incremental belief revision: start from a baseline probability and fold in signals, each a value in [0,1] with a weight, to get a revised posterior. Returns the updated posterior, the prior, per-factor contributions, posterior mean and variance, and a sharpness/calibration score. To combine N independent point predictions use predict_ensemble; to sample a full distribution use simulate_montecarlo.

Input parameters:

- `evidence` (array, required): Pieces of evidence to fold in.
- `prior` (number, required): Prior probability of the event (0..1). Used to seed Beta(prior*10, (1-prior)*10).

Output parameters:

- `calibrationScore` (number): 1 - sqrt(variance); higher = sharper posterior.
- `factors` (array)
- `posterior` (number): Updated probability after folding in evidence.
- `posteriorMean` (number)
- `posteriorVariance` (number)
- `priorProbability` (number)

### `predict_ensemble` (~155 tokens)

Combine 2+ model point predictions into one consensus using weighted voting, stacking, or Bayesian model averaging, weighting each model by its confidence or supplied historicalAccuracy. Use to fuse heterogeneous predictors (statistical, ML, and human forecasters) into a single number with an uncertainty estimate. Returns the consensus value and confidence, per-model weight share, Shannon entropy of the weights, a cross-model agreement score, epistemic/aleatoric/total uncertainty with a confidence interval, and per-model contributions. To score agreement on a single event probability instead, use score_convergence.

Input parameters:

- `method` (string): Combination method (default: weighted-voting).
- `predictions` (array, required): Predictions from each model (at least 2).

Output parameters:

- `agreement` (number): Cross-model agreement score (1=all agree, 0=disagree).
- `confidence` (number): Aggregate confidence.
- `consensus` (number): Combined point prediction.
- `entropy` (number): Shannon entropy of the weight distribution (higher = more diversified).
- `method` (string)
- `modelContributions` (object)
- `uncertainty` (object)
- `weights` (object): modelId → weight used.

### `optimize_evolve` (~268 tokens)

Run a genetic algorithm over a fixed-length gene vector (binary, integer, real, or permutation bounds) against a weighted-sum fitness, with an optional Pareto frontier for multi-objective runs. Use for discrete or mixed search spaces (feature selection, integer allocation, permutation/TSP-style problems) or when you want several non-dominated solutions. Returns the best chromosome and fitness, the Pareto frontier when applicable, the convergence generation, total generations, and recent fitness history; results vary run to run (stochastic). For smooth continuous objectives, use optimize_cmaes.

Input parameters:

- `bounds` (object)
- `crossoverMethod` (string): Default: single-point.
- `crossoverRate` (number): Crossover probability (default: 0.8).
- `fitnessWeights` (array): Per-gene weights in the default linear fitness sum. Length should equal geneLength.
- `geneLength` (integer, required): Number of genes (variables) per chromosome.
- `maxGenerations` (integer): Default: 100, capped at 500.
- `mutationRate` (number): Per-gene mutation probability (default: 0.01).
- `populationSize` (integer): Default: 100, capped at 500.
- `selectionMethod` (string): Default: tournament.

Output parameters:

- `bestChromosome` (object)
- `convergenceGeneration` (integer): Generation at which best fitness stopped improving.
- `executionTimeMs` (number)
- `fitnessHistory` (array): Last 20 generations' best fitness.
- `paretoFrontier` (array): Non-dominated solutions (multi-objective only).
- `totalGenerations` (integer)

### `simulate_scenario` (~148 tokens)

Compare named what-if scenarios against a base case where the outcome metric is the sum of the input variables, and rank which variables swing the outcome most. Use for budget sensitivity, deal/forecast what-ifs, or capacity planning across demand assumptions: define a base case of variable=value, then scenarios that override a subset. Returns the base outcome, each scenario's outcome with absolute and percent delta and per-variable changes, plus a sensitivity ranking by total absolute swing. For random sampling from a distribution, use simulate_montecarlo.

Input parameters:

- `baseCase` (object, required): Variable name → baseline value.
- `scenarios` (array, required): Named what-if scenarios. Each overrides any subset of baseCase variables.

Output parameters:

- `baseCase` (object)
- `results` (array)
- `scenarioCount` (integer)
- `sensitivityRanking` (array): Variables ranked by total absolute swing across scenarios.

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/whatsonyourmind-oraclaw/oraclaw-mcp-server#diagnostics

## Score history

- 2026-08-04: 66
- 2026-08-03: 62
- 2026-08-02: 62
- 2026-08-01: 18
- 2026-07-31: 24
- 2026-07-29: 42
- 2026-07-28: 42
- 2026-07-27: 42

## Links

- npm package: https://www.npmjs.com/package/@oraclaw/mcp-server
- Socket report: https://socket.dev/npm/package/@oraclaw/mcp-server
- Repository: https://github.com/Whatsonyourmind/oraclaw
- Changelog RSS feed: https://verifymcp.io/servers/whatsonyourmind-oraclaw/oraclaw-mcp-server/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/whatsonyourmind-oraclaw/oraclaw-mcp-server/changelog.json
- HTML version of this page: https://verifymcp.io/servers/whatsonyourmind-oraclaw/oraclaw-mcp-server