CAT
/MCP
SkillsMCPMarketplacesDigestToolsAdvertise

This week in Claude

Every Monday: Claude Code, Agent SDK, MCP, and the Anthropic platform moves worth your time.

Skills by Category
Frontend DevelopmentBackend & APIsTesting & QASecurityDevOps & CI/CDGit & Pull RequestsDocumentationCode Review & QualityAI & Agent BuildingSkill Development
MCP Servers by Category
Sales & MarketingWeb & Browser AutomationDatabasesAI & LLM ToolsCloud & InfrastructureCommunication & MessagingDeveloper ToolsDesign & CreativeDocuments & KnowledgeSearch & Web Crawling
Marketplaces by Category
AI Agents & OrchestrationLLM IntegrationDevelopment ToolsFrontend & UIBackend & APIsDatabasesTesting & Code QualityDevOps & CloudSecurity & ComplianceGit & Version Control

Cross AI Tools

Discover Claude Code plugins, extensions, and tools. Automatically updated directory of Anthropic Claude AI marketplaces with development tools, productivity plugins, and integrations.

Resources

  • Browse Skills
  • Browse MCP Servers
  • Browse Marketplaces
  • Plugins Reference

Community

  • About
  • Tools
  • Feedback
  • Privacy Policy
  • Advertise

Built for the Claude Code community with Claude Code by @mertduzgun

Independent project, not affiliated with Anthropic

Tradememory Protocol

mnemox-ai/tradememory-protocol
1.2k17 toolsSTDIOregistry active
Summary

If you're building AI trading agents, this solves the memory problem. Your agent can execute trades but can't remember what happened last time it saw similar conditions. TradeMemory gives you 17 MCP tools to record trades across five memory layers (episodic, semantic, procedural, affective, trade records) and recall them with outcome-weighted scoring. Before trading, query recall_memories to see past setups. After, call remember_trade to log everything. You get confidence tracking, drawdown alerts, and SHA-256 audit trails for compliance. Works with any broker or market since it only stores decisions, never executes. Particularly useful if you're running pre-flight checklists or need MiFID II documentation for algorithmic trading decisions.

Install to Claude Code

verified
claude mcp add tradememory-protocol -- uvx tradememory-protocol

Run in your terminal. Replace YOUR_* placeholders with real values; add --scope user to install for every project.

Review the command, arguments, and environment values before installing — MCP servers run with your local permissions.

CodeRabbit
CodeRabbit
AI writes the code. CodeRabbit catches the slop.
Try For Free →
Keep your Mac awake
Keep your Mac awake
Keep your Mac awake while Claude Code and 40+ AI agents run. Sleeps when they're idle.
One time payment $9 →
Context.devContext.dev
Context.dev
Integrate web data into your AI product. One API to scrape website & brand data.
Get API Key Now →
Make your agent a DeFi expert
Make your agent a DeFi expert
Agent, run crypto. Access onchain data & trade routes via 1inch.
Install now →
Make money from your Skills
Make money from your Skills
On Capafy, your Skill runs online 24/7 as an agent product, and you get paid every time someone uses it.
Start earning →
AppSignal
AppSignal
Monitor with ease. Code with confidence.
Start Free Trial →
CodeRabbit
CodeRabbit
AI writes the code. CodeRabbit catches the slop.
Try For Free →
Keep your Mac awake
Keep your Mac awake
Keep your Mac awake while Claude Code and 40+ AI agents run. Sleeps when they're idle.
One time payment $9 →
Context.devContext.dev
Context.dev
Integrate web data into your AI product. One API to scrape website & brand data.
Get API Key Now →
Make your agent a DeFi expert
Make your agent a DeFi expert
Agent, run crypto. Access onchain data & trade routes via 1inch.
Install now →
Make money from your Skills
Make money from your Skills
On Capafy, your Skill runs online 24/7 as an agent product, and you get paid every time someone uses it.
Start earning →
AppSignal
AppSignal
Monitor with ease. Code with confidence.
Start Free Trial →

Tools

Verified live against the running server on Jun 11, 2026.

verified live17 tools
store_trade_memoryStore a trade decision with full context into memory. Call this after executing a trade to build your memory bank. Include market_context and reflection for better recall later.10 params

Store a trade decision with full context into memory. Call this after executing a trade to build your memory bank. Include market_context and reflection for better recall later.

Parameters* required
pnlvalue
Profit/loss in account currency (if trade is closed)
symbol*string
Trading instrument (e.g. "XAUUSD")
trade_idvalue
Optional custom ID. Auto-generated if omitted.
direction*string
"long" or "short"
timestampvalue
ISO format timestamp. Defaults to now (UTC).
exit_pricevalue
Exit price (if trade is closed)
reflectionvalue
What you learned from this trade
entry_price*number
Entry price of the trade
strategy_name*string
Name of the strategy used (e.g. "VolBreakout")
market_context*string
Description of market conditions when trade was taken
recall_similar_tradesFind past trades with similar market context. Use this before making a trade to learn from past experience. Returns trades with their reflections and outcomes. Uses OWM scoring when episodic memories exist, falls back to keyword matching.4 params

Find past trades with similar market context. Use this before making a trade to learn from past experience. Returns trades with their reflections and outcomes. Uses OWM scoring when episodic memories exist, falls back to keyword matching.

Parameters* required
limitinteger
Max number of results (default 5)default: 5
symbol*string
Trading instrument to filter by (e.g. "XAUUSD")
strategy_namevalue
Optional strategy filter
market_context*string
Current market conditions to match against
get_strategy_performanceGet aggregate performance stats per strategy. Use this to evaluate which strategies are working and which need adjustment.2 params

Get aggregate performance stats per strategy. Use this to evaluate which strategies are working and which need adjustment.

Parameters* required
symbolvalue
Filter by symbol. Returns all symbols if omitted.
strategy_namevalue
Filter by strategy name. Returns all strategies if omitted.
get_trade_reflectionGet the full context and reflection for a specific trade. Use this to deep-dive into a particular trade's reasoning and lessons.1 params

Get the full context and reflection for a specific trade. Use this to deep-dive into a particular trade's reasoning and lessons.

Parameters* required
trade_id*string
The trade ID to look up
remember_tradeStore a trade into OWM multi-layer memory with automatic updates. Writes to episodic memory and automatically updates semantic (Bayesian), procedural (running averages), and affective (EWMA confidence/streaks). Also writes to trade_records for backward compatibility.15 params

Store a trade into OWM multi-layer memory with automatic updates. Writes to episodic memory and automatically updates semantic (Bayesian), procedural (running averages), and affective (EWMA confidence/streaks). Also writes to trade_records for backward compatibility.

Parameters* required
pnl*number
Profit/loss in account currency
pnl_rvalue
P&L as R-multiple (risk units). Improves OWM scoring quality.
symbol*string
Trading instrument (e.g. "XAUUSD")
trade_idvalue
Optional custom ID. Auto-generated if omitted.
direction*string
"long" or "short"
timestampvalue
ISO format timestamp. Defaults to now (UTC).
confidencenumber
Agent confidence level 0-1 (default 0.5)default: 0.5
exit_price*number
Exit price of the trade
reflectionvalue
Lessons learned from this trade
entry_price*number
Entry price of the trade
strategy_name*string
Strategy used (e.g. "VolBreakout")
context_atr_d1value
ATR(14) on D1 in dollars
context_regimevalue
Market regime (trending_up/trending_down/ranging/volatile)
market_context*string
Description of market conditions
max_adverse_excursionvalue
Maximum adverse excursion during the trade
recall_memoriesRecall memories using OWM outcome-weighted scoring. Queries episodic and semantic memories, scores them by outcome quality, context similarity, recency, confidence, and affective modulation. Returns ranked memories with score breakdown.7 params

Recall memories using OWM outcome-weighted scoring. Queries episodic and semantic memories, scores them by outcome quality, context similarity, recency, confidence, and affective modulation. Returns ranked memories with score breakdown.

Parameters* required
limitinteger
Max results (default 10)default: 10
symbol*string
Trading instrument (e.g. "XAUUSD")
memory_typesvalue
Types to query (default: ["episodic", "semantic"])
strategy_namevalue
Optional strategy filter
context_atr_d1value
Current ATR(14) on D1 in dollars
context_regimevalue
Current market regime (trending_up/trending_down/ranging/volatile)
market_context*string
Current market conditions to match against
get_behavioral_analysisGet behavioral analysis from procedural memory. Returns aggregate trading behavior stats: hold times, disposition ratio, lot sizing variance, and Kelly criterion comparison.2 params

Get behavioral analysis from procedural memory. Returns aggregate trading behavior stats: hold times, disposition ratio, lot sizing variance, and Kelly criterion comparison.

Parameters* required
symbolvalue
Filter by symbol. Returns all if omitted.
strategy_namevalue
Filter by strategy name. Returns all if omitted.
get_agent_stateGet the current agent affective state (confidence, risk, drawdown). Returns confidence level, risk appetite, drawdown percentage, win/loss streaks, equity tracking, and a recommended action based on current drawdown severity.

Get the current agent affective state (confidence, risk, drawdown). Returns confidence level, risk appetite, drawdown percentage, win/loss streaks, equity tracking, and a recommended action based on current drawdown severity.

No parameters — call it with no arguments.

create_trading_planCreate a prospective trading plan that activates when conditions are met. Stores a rule-based plan in prospective memory. The plan stays active until triggered, expired, or manually cancelled.6 params

Create a prospective trading plan that activates when conditions are met. Stores a rule-based plan in prospective memory. The plan stays active until triggered, expired, or manually cancelled.

Parameters* required
prioritynumber
Priority 0-1, higher = checked first (default 0.5)default: 0.5
reasoning*string
Why this plan was created
expiry_daysinteger
Days until plan expires (default 30)default: 30
trigger_type*string
Type of trigger (e.g. "market_condition", "drawdown", "time_based")
planned_action*string
JSON string describing what to do (e.g. '{"type": "skip_trade"}')
trigger_condition*string
JSON string describing when to trigger (e.g. '{"regime": "ranging"}')
check_active_plansCheck active trading plans against current market context. Queries all active prospective plans, expires any past their expiry date, and matches remaining plans against the provided context.2 params

Check active trading plans against current market context. Queries all active prospective plans, expires any past their expiry date, and matches remaining plans against the provided context.

Parameters* required
context_atr_d1value
Current ATR(14) on D1 in dollars
context_regimevalue
Current market regime (trending_up/trending_down/ranging/volatile)
evolution_fetch_market_dataFetch OHLCV market data from Binance for evolution analysis. Downloads historical price bars for backtesting and pattern discovery. Use this before discover_patterns or run_backtest to get data.3 params

Fetch OHLCV market data from Binance for evolution analysis. Downloads historical price bars for backtesting and pattern discovery. Use this before discover_patterns or run_backtest to get data.

Parameters* required
daysinteger
Number of days of history to fetch (default 90)default: 90
symbol*string
Trading pair (e.g. "BTCUSDT", "ETHUSDT")
timeframestring
Bar timeframe — "5m", "15m", "1h", "4h", "1d"default: 1h
evolution_discover_patternsDiscover trading patterns from market data using LLM analysis. Uses Claude to analyze OHLCV data and generate candidate trading patterns with entry/exit conditions. Each pattern can be backtested afterward.5 params

Discover trading patterns from market data using LLM analysis. Uses Claude to analyze OHLCV data and generate candidate trading patterns with entry/exit conditions. Each pattern can be backtested afterward.

Parameters* required
daysinteger
Days of history to analyze (default 90)default: 90
countinteger
Number of patterns to generate (default 5)default: 5
symbol*string
Trading pair (e.g. "BTCUSDT")
timeframestring
Bar timeframe — "5m", "15m", "1h", "4h", "1d"default: 1h
temperaturenumber
LLM creativity 0-1 (default 0.7, higher = more diverse)default: 0.7
evolution_run_backtestBacktest a candidate pattern against historical OHLCV data. Takes a pattern dict (from discover_patterns) and runs a vectorized backtest. Returns fitness metrics: Sharpe ratio, win rate, trade count, max drawdown, total PnL.4 params

Backtest a candidate pattern against historical OHLCV data. Takes a pattern dict (from discover_patterns) and runs a vectorized backtest. Returns fitness metrics: Sharpe ratio, win rate, trade count, max drawdown, total PnL.

Parameters* required
daysinteger
Days of history to backtest against (default 90)default: 90
symbolstring
Trading pair (e.g. "BTCUSDT")default: BTCUSDT
timeframestring
Bar timeframe — "5m", "15m", "1h", "4h", "1d"default: 1h
pattern_dict*object
CandidatePattern as dict (from discover_patterns output)
evolution_evolve_strategyRun full evolution loop — generate, backtest, select, eliminate. Multi-generation strategy evolution: generates candidate patterns via LLM, backtests on in-sample data, validates survivors on out-of-sample data, eliminates weak hypotheses. Returns graduated strategies and grav...5 params

Run full evolution loop — generate, backtest, select, eliminate. Multi-generation strategy evolution: generates candidate patterns via LLM, backtests on in-sample data, validates survivors on out-of-sample data, eliminates weak hypotheses. Returns graduated strategies and grav...

Parameters* required
daysinteger
Days of history to use (default 90)default: 90
symbol*string
Trading pair (e.g. "BTCUSDT")
timeframestring
Bar timeframe — "5m", "15m", "1h", "4h", "1d"default: 1h
generationsinteger
Number of evolution generations (default 3)default: 3
population_sizeinteger
Hypotheses per generation (default 10)default: 10
evolution_get_logGet the log of past evolution runs from this session. Returns a list of all evolution runs with their results, including graduated strategies, graveyard, token usage, and backtest counts. Data is in-memory (resets on server restart).

Get the log of past evolution runs from this session. Returns a list of all evolution runs with their results, including graduated strategies, graveyard, token usage, and backtest counts. Data is in-memory (resets on server restart).

No parameters — call it with no arguments.

export_audit_trailExport Trading Decision Records for audit and compliance review. Provides a complete, tamper-evident record of trading decisions including the memory context (similar trades, beliefs) that informed each decision.5 params

Export Trading Decision Records for audit and compliance review. Provides a complete, tamper-evident record of trading decisions including the memory context (similar trades, beliefs) that informed each decision.

Parameters* required
endvalue
End date (ISO format, exclusive). E.g., "2026-04-01".
limitinteger
Maximum records to return (default 50).default: 50
startvalue
Start date (ISO format, inclusive). E.g., "2026-03-01".
strategyvalue
Filter by strategy name (e.g., "VolBreakout").
trade_idvalue
Get a single TDR by trade ID (e.g., "MT5-7047640363"). If provided, other filters are ignored.
verify_audit_hashVerify the integrity of a Trading Decision Record. Recomputes the SHA256 data_hash from stored inputs and compares with the hash computed at decision time. A mismatch indicates tampering.1 params

Verify the integrity of a Trading Decision Record. Recomputes the SHA256 data_hash from stored inputs and compares with the hash computed at decision time. A mismatch indicates tampering.

Parameters* required
trade_id*string
Trade ID to verify (e.g., "MT5-7047640363").

TradeMemory Protocol

PyPI Tests MCP Tools Smithery License: MIT

Getting Started | Use Cases | API Reference | OWM Framework | Limitations | 中文版


Your trading AI has amnesia. And regulators are starting to notice.

It makes the same mistakes every session. It can't explain why it traded. It forgets everything when the context window ends. Meanwhile, MiFID II is raising the bar for algorithmic decision documentation (Article 17). The EU AI Act demands systematic logging of AI actions (Article 14). Your competitors' agents are learning from every trade.

The AI trading stack is missing a layer. Every MCP server handles execution — placing orders, fetching prices, reading charts. None handle memory.

Your agent can buy 100 shares of AAPL but can't answer: "What happened last time I bought AAPL in this condition?"

TradeMemory is the memory layer. One pip install, and your AI agent remembers every trade, every outcome, every mistake — with SHA-256 tamper-proof audit trail.

Used in production by traders running pre-flight checklists before every position, and by EA systems logging thousands of decisions daily.

What it does

  • Before trading: ask your memory — what happened last time in this market condition? How did it end?
  • After trading: one call records everything — five memory layers update automatically
  • Safety rails: confidence tracking, drawdown alerts, losing streak detection — the system tells you when to stop

Works with any market (stocks, forex, crypto, futures), any broker, any AI platform. TradeMemory doesn't execute trades or touch your money — it only records and recalls.

Quick Start

pip install tradememory-protocol

Add to Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "tradememory": {
      "command": "uvx",
      "args": ["tradememory-protocol"]
    }
  }
}

Then tell Claude: "Record my AAPL long at $195 — earnings beat, institutional buying, high confidence."

Claude Code / Cursor / Docker
# Claude Code
claude mcp add tradememory -- uvx tradememory-protocol

# From source
git clone https://github.com/mnemox-ai/tradememory-protocol.git
cd tradememory-protocol && pip install -e . && python -m tradememory

# Docker
docker compose up -d

Full walkthrough: Getting Started (Trader Track + Developer Track)

Who uses TradeMemory

US Equity TraderForex EA SystemCompliance Team
MarketStocks (AAPL, TSLA, ...)XAUUSD (Gold)Multi-asset
HowPre-flight checklist before every tradeAutomated sync from MT5Full decision audit trail
Key valueDiscipline system — memory before every decisionRecord why signals were blocked, not just executedSHA-256 tamper-proof records for regulators
DetailsRead more →Read more →Read more →

How it works

OWM 5 Factors

  1. Recall — Before trading, retrieve past trades weighted by outcome quality, context similarity, recency, confidence, and emotional state (OWM Framework)
  2. Record — After trading, one call to remember_trade writes to five memory layers: episodic, semantic, procedural, affective, and trade records
  3. Reflect — Daily/weekly/monthly reviews detect behavioral drift, strategy decay, and trading mistakes
  4. Audit — Every decision is SHA-256 hashed at creation. Export anytime for review or regulatory submission

MCP Tools

CategoryToolsDescription
Memoryremember_trade · recall_memoriesRecord and recall trades with outcome-weighted scoring
Stateget_agent_state · get_behavioral_analysisConfidence, drawdown, streaks, behavioral patterns
Planningcreate_trading_plan · check_active_plansProspective plans with conditional triggers
Riskcheck_trade_legitimacy5-factor pre-trade gate (full / reduced / skip)
Auditexport_audit_trail · verify_audit_hashSHA-256 tamper detection + bulk export
All 17 MCP tools + REST API
CategoryTools
Core Memoryget_strategy_performance · get_trade_reflection
OWM Cognitiveremember_trade · recall_memories · get_behavioral_analysis · get_agent_state · create_trading_plan · check_active_plans
Risk & Governancecheck_trade_legitimacy · validate_strategy
Evolutionevolution_fetch_market_data · evolution_discover_patterns · evolution_run_backtest · evolution_evolve_strategy · evolution_get_log
Auditexport_audit_trail · verify_audit_hash

REST API: 35+ endpoints for trade recording, reflections, risk, MT5 sync, OWM, evolution, and audit. Full reference →

Pricing

CommunityProEnterprise
PriceFree$29/mo (Coming Soon)Contact Us
MCP tools17 tools17 tools17 tools
StorageSQLite, self-hostedHosted APIPrivate deployment
Dashboard—Web dashboardCustom dashboard
ComplianceAudit trail includedAudit trail includedCompliance reports + SLA
SupportGitHub IssuesPriority supportDedicated support
Get Started →Coming soondev@mnemox.ai

Need Help Integrating?

Building a trading AI agent and want battle-tested memory architecture?

Free 30-min strategy call — we'll map your agent's memory needs and design guardrails for your specific workflow.

dev@mnemox.ai | Book a call

We've helped traders build pre-flight checklists, connect MT5/Binance, and design custom guardrails for forex, equities, and crypto.

Enterprise & Compliance

Every trading decision your agent makes — including decisions not to trade — is recorded as a Trading Decision Record (TDR). Per-record SHA-256 content hashes are linked into a forward-chained audit ledger; every UTC day is summarised by a Merkle root which itself chains across days. Tampering with any historical record invalidates every subsequent link.

RegulationRequirementTradeMemory Coverage
MiFID II Article 17Record every algorithmic trading decision factorFull decision chain: conditions, filters, indicators, execution
EU AI Act Article 14Human oversight of high-risk AI systemsExplainable reasoning + memory context for every decision
EU AI Act Article 12Automatic, tamper-resistant logs over system lifetimeLinked SHA-256 chain + daily Merkle roots (RFC 3161 TSA in Phase 1.5)
# Verify a single record hasn't been tampered with
verify_audit_hash(trade_id="MT5-7047640363")
# → {"verified": true, "chain_entry": {"sequence_num": 42, ...}}

# Walk the entire chain (or a slice) end-to-end
verify_audit_chain(from_seq=1, to_seq=None)
# → {"verified": true, "checked_count": 1284, "first_break_at": null}

# Daily Merkle root — single 32-byte anchor over every TDR for that day
get_daily_root(date="2026-05-14")
# → {"verified": true, "root_hash": "a05544...", "record_count": 18}

# Bulk export for regulatory submission
GET /audit/export?strategy=VolBreakout&start=2026-03-01&format=jsonl

See LIMITATIONS.md for the full audit-chain maturity statement, including what's not in v0.5.2 yet (TSA timestamping, external anchoring, zkML proof of inference).

Need a custom deployment for your fund? → dev@mnemox.ai

Security

  • Never touches API keys. TradeMemory does not execute trades, move funds, or access wallets.
  • Read and record only. Your agent passes decision context to TradeMemory. It stores it. That's it.
  • No external network calls. The server runs locally. No data is sent to third parties.
  • SHA-256 chained audit ledger. Every record is hashed at creation and linked to the previous record. Daily Merkle roots anchor the chain. Verify integrity at the record, slice, or day level.
  • 1,428 tests passing. Full test suite with CI.

Research Status

TradeMemory's OWM framework is grounded in cognitive science (Tulving 1972) and reinforcement learning (Schaul et al. 2015). Current status:

  • OWM five-factor scoring: implemented, tested (1,300+ tests)
  • Statistical validation: DSR, MBL implemented (Bailey-de Prado 2014)
  • Audit trail: SHA-256 tamper-proof TDR
  • Evolution engine: research phase (strategy generation works, statistical gate pass rate under optimization)
  • Hybrid recall: OWM-only mode active, vector fusion available when embeddings configured
  • Empirical validation: ongoing (n=40 trades, target n>=100 for statistical significance)

Documentation

DocDescription
Getting StartedInstall → first trade → pre-flight checklist
Use Cases3 real-world production scenarios
API ReferenceAll REST endpoints
OWM FrameworkOutcome-Weighted Memory theory
ArchitectureSystem design & layer separation
TutorialDetailed walkthrough
MT5 SetupMetaTrader 5 integration
Research LogEvolution experiments & data
Failure Taxonomy11 trading AI failure modes
中文版Traditional Chinese

Contributing

See Contributing Guide · Security Policy

Star History

MIT — see LICENSE. For educational/research purposes only. Not financial advice.

Built by Mnemox
Featured
CodeRabbit
CodeRabbit
AI writes the code. CodeRabbit catches the slop.
Try For Free →
Keep your Mac awake
Keep your Mac awake
Keep your Mac awake while Claude Code and 40+ AI agents run. Sleeps when they're idle.
One time payment $9 →
Context.devContext.dev
Context.dev
Integrate web data into your AI product. One API to scrape website & brand data.
Get API Key Now →
Make your agent a DeFi expert
Make your agent a DeFi expert
Agent, run crypto. Access onchain data & trade routes via 1inch.
Install now →
Make money from your Skills
Make money from your Skills
On Capafy, your Skill runs online 24/7 as an agent product, and you get paid every time someone uses it.
Start earning →
AppSignal
AppSignal
Monitor with ease. Code with confidence.
Start Free Trial →
Categories
AI & LLM ToolsFinance & Commerce
Registryactive
Packagetradememory-protocol
TransportSTDIO
Tools verifiedJun 11, 2026
UpdatedMar 2, 2026
View on GitHub

Related AI & LLM Tools MCP Servers

View all →
SkillFM LLM Cost Optimizer

io.github.ericm1018/skillfm-llm-cost-optimizer-openai-anthropic-usage

LLM cost optimizer for OpenAI, Anthropic, token usage, BYOK, and SkillFM Beacon audits.
Llm Orchestration Agent

io.github.mikerawsonnz/llm-orchestration-agent

Run a prompt through a LangChain (system + human) chain over Gemini on Vertex AI; optional LangSmith
Authenticated Llm Agent

io.github.mikerawsonnz/authenticated-llm-agent

JWT-gated LLM gateway: authenticate (bcrypt/JWT), then run a LangChain-on-Vertex Gemini completion.
Copilot Memory MCP

labforgedev/copilot-memory-mcp

Persistent semantic memory for AI agents using local ChromaDB vector search. No cloud required.
1
Agent Prompt Injection Firewall Mcp

csoai-org/agent-prompt-injection-firewall-mcp

The WAF for agents. Pattern-based + heuristic firewall scans prompts, RAG documents, tool argume...
Authenticated Multi Llm Agent

io.github.mikerawsonnz/authenticated-multi-llm-agent

Google-OAuth-gated LLM gateway: verify a Google ID token, then run a Gemini (Vertex AI) completion f