rUv ruvnet

Agentic Coding MCPs

Overview

Powered by composio this MCP.json provides detailed information on Model Context Protocol (MCP) integration capabilities and enables seamless agent workflows by connecting to more than 80 servers.

It covers development, AI, data management, productivity, cloud storage, e-commerce, finance, communication, and design. Each server offers specialized tools, allowing agents to securely access, automate, and manage external services through a unified and modular system. This approach supports building dynamic, scalable, and intelligent workflows with minimal setup and maximum flexibility.

Install via NPM

Quantum magnetic navigation

Imagine a navigation system that never needs satellites, radios, or signals of any kind. Instead, it carries a tiny quantum sensor that quietly “listens” to Earth’s own magnetic field. Every location on the planet has a unique magnetic fingerprint—subtle variations in strength and direction that arise from the rocks and minerals below our feet. By comparing what the sensor reads to a pre‑loaded map of those fingerprints, a robot or vehicle can pinpoint its position with GPS‑level accuracy.

Because it emits nothing, this approach is immune to jamming or spoofing. It works everywhere — indoors, underground, underwater, in dense cities or deep forests — where GPS and other systems fail. Drones can continue mapping pipelines under bridges, warehouse robots can navigate tunnels without beacons, and self‑driving cars can stay on course in concrete canyons. For military or search‑and‑rescue missions, the technology offers stealth and reliability when every second counts.

In short, qu

Creating Custom NPX Components with Vite.js

Creating custom components that can be installed and executed via NPX is a powerful way to share your code across multiple projects. With Vite.js, this process becomes more streamlined. Here's a comprehensive guide on how to build and publish your own NPX components.

Setting Up Your Project

First, you need to create a new Vite project:

npm create vite@latest my-npx-component

Building a VSCode Remote Access MCP Server for Collaborative Agentic Development

Before diving into the implementation, let's understand what makes this solution valuable: it creates a bridge between isolated development environments, enabling real-time collaboration without the limitations of traditional remote development approaches.

MCP Server Architecture

The MCP (Model Context Protocol) server architecture consists of several key components that work together to facilitate communication between multiple VSCode instances:

A centralized MCP server that handles message routing and state synchronization
Client connections from multiple workspaces or codespaces

Great. I’ll develop a phased implementation plan, edge function code, deployment strategy, user guide, and full documentation for a key rotator using Deno Edge Functions. This will focus on rotating Gemini 2.5 Pro API keys to handle 429 rate limits efficiently.

I’ll return with a clear breakdown of components, including a secure architecture, key storage and cycling logic, usage limits, and guidance for setup and customization.

Secure API Key Rotator for Google Gemini 2.5 Pro (Deno Edge Functions)

Overview: This solution is an edge-deployed proxy that securely rotates through a pool of Google Gemini 2.5 Pro API keys to avoid hitting per-key rate limits (e.g. free-tier limit of ~2 requests/minute (Gemini 2.5 Pro via OpenRouter triggers RESOURCE_EXHAUSTED despite API key and usage being within free-tier limits · Issue #2000 · RooVetGit/Roo-Code · GitHub)). By

Tutorial: Building an Agentic AI System with Deductive & Inductive Reasoning

1. Introduction

Modern AI systems increasingly require the ability to make decisions in complex and dynamic environments. One promising approach is to create an agentic AI system that combines:

Deductive Reasoning: Rule-based logic that guarantees conclusions when premises hold true.
Inductive Reasoning: Data-driven inference that generalizes from specific cases to handle uncertainty.

By integrating these two methods, often referred to as neuro-symbolic AI, an agent can provide transparent, explainable decisions while also adapting to new data. This tutorial explains the concepts behind this approach and shows you how to build an edge-deployable ReAct agent using Deno.

	{
	"slug": "supabase-admin",
	"name": "🔐 Supabase Admin",
	"roleDefinition": "You are the Supabase database, authentication, and storage specialist. You design and implement database schemas, RLS policies, triggers, and functions for Supabase projects. You ensure secure, efficient, and scalable data management.",
	"customInstructions": "review supabase using @/mcp-instructions.txt. Never use the CLI, only the MCP server. You are responsible for all Supabase-related operations and implementations. You:\n\n• Design PostgreSQL database schemas optimized for Supabase\n• Implement Row Level Security (RLS) policies for data protection\n• Create database triggers and functions for data integrity\n• Set up authentication flows and user management\n• Configure storage buckets and access controls\n• Implement Edge Functions for serverless operations\n• Optimize database queries and performance\n\nWhen using the Supabase MCP tools:\n• Always list available organizations before creating projects\n• G

	Goal: Generate secure, testable code via XML‑style tool

	0 · Onboarding

	First time a user speaks, reply with one line and one emoji: “👋 Ready when you are!”

	⸻

	1 · Unified Role Definition

	# SPARC Agentic Development Rules

	Core Philosophy

	1. Simplicity
	- Prioritize clear, maintainable solutions; minimize unnecessary complexity.

	2. Iterate
	- Enhance existing code unless fundamental changes are clearly justified.

	{
	"customModes": [
	{
	"slug": "sparc",
	"name": "⚡️ SPARC Orchestrator",
	"roleDefinition": "You are SPARC, the orchestrator of complex workflows. You break down large objectives into delegated subtasks aligned to the SPARC methodology. You ensure secure, modular, testable, and maintainable delivery using the appropriate specialist modes.",
	"customInstructions": "Follow SPARC:\n\n1. Specification: Clarify objectives and scope. Never allow hard-coded env vars.\n2. Pseudocode: Request high-level logic with TDD anchors.\n3. Architecture: Ensure extensible system diagrams and service boundaries.\n4. Refinement: Use TDD, debugging, security, and optimization flows.\n5. Completion: Integrate, document, and monitor for continuous improvement.\n\nUse `new_task` to assign:\n- spec-pseudocode\n- architect\n- code\n- tdd\n- debug\n- security-review\n- docs-writer\n- integration\n- post-deployment-monitoring-mode\n- refinement-optimization-mode\n\nValidate:\n✅ Files < 500 lines\n✅ No hard-coded