justvugg

I built dbcli, a lightweight database CLI designed specifically for AI agents that need fast, low-overhead access to relational databases.

The main idea is to make database introspection and querying simple and efficient when an agent has shell access. With a single command (dbcli snap), you can retrieve schema details, table relationships, and basic data profiling (column stats, ranges, cardinality) without stitching together multiple queries or tools. This helps reduce token usage and unnecessary round-trips in agent workflows.

Dbcli supports multiple databases, including PostgreSQL, MySQL, MariaDB, SQLite, DuckDB, ClickHouse, SQL Server, and others via optional drivers. It allows running queries, executing SQL files, and writing data directly from the CLI. There’s no server process or external service required — just install locally with:

pip install -e .

The goal is to provide a simple, agent-agnostic alternative to heavier protocol-based approaches, working with any system capable of executing shell commands.

I’d really appreciate feedback, especially from those building AI agents or tools that require structured database access.

Github repo: https://github.com/JustVugg/dbcli

Hi everyone,

I’d like to share a tool I built, called dbcli. It’s a database CLI designed specifically for AI agents, enabling them to understand and interact with any database using a single command. Whether you're developing AI systems that require database access or need a fast and efficient way to query and profile your databases, dbcli is optimized for speed and simplicity.

Key Features:

Instant Database Context: Use dbcli snap to get schema, data profiling, and relationships in one call—no need for multiple tool invocations.

Optimized for AI Agents: Designed to minimize overhead for AI systems. Get database insights and query results without wasting tokens or setup time.

Lightweight: No server setup, no SDK installation—just pip install dbcli and you’re ready to go.

Multi-database Support: Supports SQLite, PostgreSQL, MySQL, MariaDB, DuckDB, ClickHouse, SQL Server, and more.

Simple Queries and Writes: Run SQL queries, write data, and execute SQL files with ease.

Data Profiling: Get real-time stats on column distributions, ranges, and cardinality to better understand your data.

Integration: Easy integration with AI agents like Claude, LangChain, and others.

Why dbcli over MCP?

Zero context cost: Unlike MCP, which can consume hundreds of tokens just to fetch schema data, dbcli provides everything in a single command with no token overhead.

Faster Setup: Minimal installation and no external configuration needed—just install with pip install dbcli.

Works for Any Agent: dbcli works with any agent that has shell access—no need for special protocol support.

Installation: pip install dbcli

Optional database drivers:

pip install "dbcli[postgres]"pip install "dbcli[mysql]"pip install "dbcli[all]"

Check out the project on GitHub: https://github.com/JustVugg/dbcli

Looking forward to your feedback and any suggestions for improvements!

I built Wiredigg, an open-source network traffic analysis and security tool written in Python. It combines real-time packet capture, protocol inspection, machine learning-based anomaly detection, and local LLM analysis via Ollama.

The goal is to provide interactive network visibility with AI-assisted threat interpretation, while remaining local-first and easy to run. A Windows executable build is also available.

Repo: https://github.com/JustVugg/Wiredigg

⸻

What it does

Real-time packet capture • Live traffic sniffing • Protocol analysis (TCP, UDP, ICMP, HTTP, etc.) • Filtering by IP, port, and protocol • Promiscuous mode support

Machine learning anomaly detection • Detection of unusual traffic patterns • Threat classification with severity levels • False-positive marking and incremental retraining • User-assisted model refinement

Ollama integration (local LLM) • Sends flagged anomalies to a locally running model via Ollama • Generates contextual, human-readable explanations • Adds reasoning on top of statistical detections • Fully offline if Ollama is local

Threat intelligence & dashboards • Malicious IP/domain checks • Interactive tables and traffic statistics • Graph-based visualizations • Exportable reports (HTML, JSON, text)

IoT & device analysis • Device identification and classification • Behavioral pattern analysis • Risk evaluation based on traffic activity

Custom packet tools • Manual packet crafting for testing • Control over IP, port, protocol, and payload

Running it

From source:

git clone https://github.com/JustVugg/Wiredigg pip install -r requirements.txt python wiredigg.py

Administrator/root privileges are required for packet capture.

Alternatively, you can use the provided Windows .exe build.

⸻

Why I built it

Many packet analyzers are either: • CLI-heavy and technical • Or large enterprise systems

I wanted something: • Visual • AI-augmented • Local-first • Extensible in Python • Usable for labs, small networks, and learning

Happy to get feedback, especially on the ML and Ollama integration approach.

PolyMCP is a framework that exposes functions (in Python or TypeScript) as MCP tools, serves them through standardized MCP servers, and orchestrates them with autonomous agents capable of planning and executing complex workflows.

With PolyMCP, you can: 1. Expose existing functions (in Python or TypeScript) as MCP tools without rewriting the code. 2. Use the PolyClaw agent to dynamically orchestrate tools, break down complex tasks, and adapt to failures, all running in isolated environments via Docker.

PolyMCP is ideal for enterprise automation, DevOps, data pipelines, and internal tool orchestration.

GitHub Repo: https://github.com/poly-mcp/PolyMCP

Hi everyone, I have created EasyMemory: a lightweight, fully local memory backend for chatbots, agents and any MCP-compatible LLM (Claude, GPT, Gemini, Ollama…). Key points: • Auto-saves every conversation • Ingests PDFs, DOCX, Markdown vaults, folders • Hybrid retrieval: vector + keyword + graph (no extra libs needed) • Built-in MCP server → plug into Claude Desktop, custom agents, etc. • 100% offline, data in ~/.easymemory • Enterprise extras: OAuth2, API keys, rate limiting, audit logs • Bonus: Slack JSON import, Notion/GDrive folder indexing Quick start (MCP server):

easymemory-server --port 8100

Then point Claude Desktop or your agent to http://localhost:8100/mcp. Or chat with Ollama:

easymemory-agent --provider ollama --model llama3.1:8b

Python usage:

from easymemory.agent import EasyMemoryAgent async with EasyMemoryAgent(llm_provider="ollama", model="llama3.1:8b") as agent: print(await agent.chat("Remember: I prefer dark mode.")) # Later... print(await agent.chat("What UI do I prefer?")) # → "You prefer dark mode"

MIT licensed, minimal deps, early stage. Repo: https://github.com/JustVugg/easymemory Looking for feedback on: • What retrieval mix works best for your long-term memory needs? • Pain points with current local memory solutions? • Nice-to-have integrations? Thanks!

Hi HN, Built llm-use: a lightweight Python toolkit for efficient agent workflows with multiple LLMs. Core pattern: strong model (Claude/GPT-4o/big local) for planning + synthesis; cheap/local workers for parallel subtasks (research, scrape, summarize, extract…). Features: • Mix Anthropic, OpenAI, Ollama, llama.cpp • Smart router: cheap/local first, escalate only if needed (learned + heuristic) • Parallel workers (–max-workers) • Real scraping + cache (BS4 or Playwright) • Offline-first (full Ollama support) • Cost tracking ($ for cloud, 0 local) • TUI chat + MCP server mode • Local session logs Quick example (hybrid):

python3 cli.py exec \ --orchestrator anthropic:claude-3-7-sonnet-20250219 \ --worker ollama:llama3.1:8b \ --enable-scrape \ --task "Summarize 6 recent sources on post-quantum crypto"

Or routed version:

python3 cli.py exec \ --router ollama:llama3.1:8b \ --orchestrator openai:o1 \ --worker gpt-4o-mini \ --task "Explain recent macOS security updates"

MIT licensed, minimal deps, embeddable. Repo: https://github.com/llm-use/llm-use Feedback welcome on: • Routing heuristics you’d find useful • Pain points with agent costs / local vs cloud • Missing integrations? Thanks!

I built PolyMCP, a framework and runtime for exposing Python functions as MCP tools, serving them via standardized MCP servers, and orchestrating them with autonomous agents that can plan and execute multi‑step workflows.

PolyMCP is more than just an MCP server: it turns existing Python code into agent‑ready tools and gives agents the ability to discover, compose, and orchestrate across multiple services with adaptive planning and real‑world execution support.

Key parts of the ecosystem:

1) Expose Python functions as MCP tools Use existing Python functions directly as MCP tools without rewriting them:

from polymcp.polymcp_toolkit import expose_tools_http

def add(a: int, b: int) -> int: return a + b

app = expose_tools_http([add], title="Math Tools")

Type hints automatically generate structured tool schemas, and input/output validation and error handling are included. Multiple functions can be exposed on the same server.

2) Autonomous agent: PolyClaw PolyClaw goes beyond tool calling. It: • Decomposes complex tasks into executable steps • Selects and orchestrates MCP tools dynamically • Starts or connects to MCP servers on demand • Validates outputs before proceeding • Adapts plans when execution fails • Runs everything in isolated Docker containers

Example run:

polymcp agent run \ --type polyclaw \ --query "Build a sales reporting pipeline and test it end‑to‑end" \ --model minimax‑m2.5:cloud \ --verbose

Under the hood, the system plans, provisions infrastructure as needed, executes steps sequentially or in parallel, and handles adaptive replanning when something fails.

Why this matters

Most AI agent systems today either call tools statically or assume the infrastructure already exists. PolyMCP instead: • Makes existing Python code agent‑ready with minimal friction • Standardizes tools via MCP so multiple agents and services can interact with them • Provides autonomous orchestration across multiple services • Spins up infrastructure dynamically when needed • Validates step results and recovers from failures • Uses Docker for safe, isolated execution

PolyMCP is useful for enterprise automation, DevOps workflows, data pipelines, internal tooling orchestration, and any complex multi‑tool reasoning tasks where agents must plan and execute reliably.

Repo: https://github.com/poly‑mcp/PolyMCP

Happy to answer questions.

I built PolyClaw, an autonomous agent for the PolyMCP ecosystem inspired by OpenClaw.

PolyClaw doesn’t just call tools. It plans, executes, adapts — and even creates MCP servers when needed.

It’s designed for real-world, multi-step production workflows where an agent must: • Orchestrate multiple tools • Spin up infrastructure dynamically • Recover from failures • Deliver complete, end-to-end results

⸻

What PolyClaw Does • Decomposes complex tasks into executable steps • Dynamically selects and orchestrates MCP tools • Spins up or connects to MCP servers on demand • Adapts if execution fails or context changes • Validates outputs before proceeding • Runs Docker-first for isolation and safety • Built with Python + TypeScript

PolyClaw is not just a tool-caller — it’s an infrastructure-aware agent.

⸻

Run PolyClaw (via PolyMCP CLI)

polymcp agent run \ --type polyclaw \ --query "Build a sales reporting pipeline and test it end-to-end" \ --model minimax-m2.5:cloud \ --verbose

What happens behind the scenes: 1. The task is decomposed into structured steps 2. Required MCP tools are identified 3. MCP servers are started or connected 4. Steps execute (sequentially or in parallel) 5. Outputs are validated 6. Failures trigger adaptive replanning 7. A complete, end-to-end result is returned

All containerized. All isolated.

⸻

Why This Matters

Most AI agents today: • Call tools statically • Assume infrastructure already exists • Break on multi-step failures

PolyClaw instead: • Builds the infrastructure it needs • Orchestrates across multiple MCP servers • Handles retries and adaptive planning • Is safe to run in Dockerized environments

This makes it viable for: • Enterprise workflows • DevOps automation • Data pipelines • Internal tooling orchestration • Complex multi-tool reasoning tasks

PolyClaw turns PolyMCP from simple tool exposure into a fully autonomous orchestration layer.

Repo: https://github.com/poly-mcp/PolyMCP

Happy to answer questions.

I built PolyClaw, an OpenClaw-inspired autonomous agent for the PolyMCP ecosystem.

PolyClaw doesn’t just call tools. It plans, executes, adapts — and creates MCP servers when needed.

It’s designed for real multi-step, production workflows where agents must orchestrate tools, spin up infrastructure, recover from errors, and deliver complete results end-to-end.

⸻

What PolyClaw Does • Plans complex multi-step tasks • Executes and orchestrates MCP tools dynamically • Adapts when steps fail or context changes • Creates and connects MCP servers on the fly • Runs Docker-first for safety and isolation • Built with Python and TypeScript

PolyClaw is not just a tool caller — it’s an infrastructure-aware agent.

⸻

Run PolyClaw with Ollama

You can launch PolyClaw directly from the PolyMCP CLI:

polymcp agent run \ --type polyclaw \ --query "Build a sales reporting pipeline and test it end-to-end" \ --model minimax-m2.5:cloud \ --verbose

What happens behind the scenes: 1. The agent decomposes the task. 2. It determines which MCP tools are required. 3. It spins up or connects to MCP servers. 4. It executes steps in sequence (or parallel when needed). 5. It validates outputs. 6. It adapts if something fails. 7. It returns a complete result.

All containerized. All isolated.

⸻

Why This Matters

Most AI agents: • Call tools statically • Assume infrastructure already exists • Break on multi-step failure

PolyClaw: • Builds the infrastructure it needs • Orchestrates across multiple MCP servers • Handles retries and adaptive planning • Is safe to run in Dockerized environments

This makes it viable for: • Enterprise workflows • DevOps automation • Data pipelines • Internal tooling orchestration • Complex multi-tool reasoning tasks

PolyClaw turns PolyMCP from simple tool exposure only with Polyagent e unifiendpolyagent or codeagent but turn into full autonomous orchestration agent too.

Repo: https://github.com/poly-mcp/PolyMCP

Happy to answer questions,

I’ve been working on PolyMCP, an open-source framework designed to make it easier to build and coordinate agents using the Model Context Protocol (MCP).

Most MCP tooling today focuses primarily on exposing tools. PolyMCP instead targets the agent layer: how to structure agents properly, connect them to multiple MCP servers, and make them reliable in real-world workflows.

PolyMCP provides: • A clean way to implement MCP-compatible tool servers in Python or TypeScript • An agent abstraction that can connect to multiple MCP endpoints (stdio, HTTP, etc.) • Built-in orchestration primitives for handling multi-step tasks • A CLI to scaffold projects and run an inspector UI to debug tools and agent interactions • A modular architecture that makes it easier to compose skills and reuse components across projects

The goal is to reduce ad-hoc glue code between models and tools. Instead of manually wiring everything together for each new setup, PolyMCP offers a structured way to: • Register tools as MCP servers • Attach them to one or more agents • Explicitly manage execution flow and state • Inspect and debug interactions

It’s MIT licensed and aimed at developers building production-grade automation, internal copilots, or multi-tool assistants.

Repository: https://github.com/poly-mcp/PolyMCP

Hi everyone,

I’ve been working on PolyMCP, an open-source framework for building and orchestrating agents using the Model Context Protocol (MCP).

Most of the tooling around MCP focuses on exposing tools. With PolyMCP, the focus this time is on agents: how to structure them, connect them to multiple MCP servers, and make them reliable in real workflows.

PolyMCP provides: • A clean way to define MCP-compatible tool servers in Python or TypeScript • An agent abstraction that can connect to multiple MCP endpoints (stdio, HTTP, etc.) • Built-in orchestration primitives for multi-step tasks • A CLI to scaffold projects and run an inspector UI to debug tools and agent interactions • A modular structure that makes it easier to compose skills and reuse components across projects

The main goal is to make agent systems less ad-hoc. Instead of writing glue code around each model + tool combination, PolyMCP gives you a structured way to: • Register tools as MCP servers • Connect them to one or more agents • Control execution flow and state • Inspect and debug interactions

It’s MIT licensed and intended for developers building real-world automation, internal copilots, or multi-tool assistants.

I’d love feedback on: • The agent abstraction: is it too opinionated or not opinionated enough? • Orchestration patterns for multi-agent setups • Developer experience (CLI, inspector, project layout)

Happy to answer questions.

Hi everyone,

I am Vincenzo and i’m working on PolyMCP, an open-source framework that not only exposes Python functions as AI-callable MCP tools but also lets you orchestrate agents across multiple MCP servers.

The idea: instead of rewriting code or wrapping every function with a special SDK, you can: 1. Publish your existing Python functions as MCP tools automatically 2. Spin up a UnifiedPolyAgent that coordinates multiple MCP servers 3. Ask your agent to perform complex workflows spanning different tools

Here’s a quick example in Python:

from polymcp.polyagent import UnifiedPolyAgent, OpenAIProvider

agent = UnifiedPolyAgent( llm_provider=OpenAIProvider(model="gpt-4o-mini"), mcp_servers=[ "http://localhost:8000/mcp", "http://localhost:8001/mcp", ], verbose=True, )

answer = agent.run("Read sales data, compute totals, then summarize.") print(answer)

Or TypeScript, combining HTTP and stdio-based MCP tools:

import { UnifiedPolyAgent, OpenAIProvider } from 'polymcp-ts';

const agent = new UnifiedPolyAgent({ llmProvider: new OpenAIProvider({ apiKey: process.env.OPENAI_API_KEY!, model: 'gpt-4o-mini', }), mcpServers: ['http://localhost:3000/mcp'], stdioServers: [{ command: 'npx', args: ['@playwright/mcp@latest'] }], verbose: true, });

await agent.start(); const answer = await agent.run('Collect data and summarize.'); console.log(answer);

Use cases: • Aggregate data from multiple internal services and scripts • Build AI copilots that span different tools and languages • Automate multi-step operational workflows • Prototype agents that interact with production systems safely

Works with OpenAI, Anthropic, and Ollama models, including local deployments.

GitHub links: • Core & Agent: https://github.com/poly-mcp/PolyMCP • Inspector: https://github.com/poly-mcp/PolyMCP-Inspector • SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps

I’d love feedback from anyone exploring agent orchestration or building multi-tool AI pipelines.

PolyMCP now supports compiling Python MCP tools to WebAssembly using Pyodide.

This means any Python function exposed as an MCP tool can now run directly in the browser, Node.js, or edge workers, fully sandboxed, without a Python server.

Compile your tools, serve the bundle, and AI agents can call them instantly in WASM environments. Existing MCP features like input validation, error handling, and tool orchestration work seamlessly.

example:

from polymcp.polymcp_toolkit import expose_tools_wasm

def add(a: int, b: int) -> int: """Add two numbers""" return a + b

compiler = expose_tools_wasm([add]) bundle = compiler.compile(output_dir="./dist")

Open dist/demo.html in your browser — the add tool runs entirely in WASM.

Why it matters • No Python server required: runs client-side or on edge • Secure: sandboxed execution • Plug-and-play: multiple tools in one WASM bundle • Ideal for interactive demos, edge AI apps, or browser-based automation

Repo: https://github.com/poly-mcp/Polymcp

Hi HN,

I built PolyMCP, an open-source framework around the Model Context Protocol (MCP) that lets you expose existing Python functions as AI-callable tools — without rewriting them or adopting a custom SDK.

The goal is simple: If you already have working Python code, you should be able to make it accessible to LLM agents in minutes.

What it does

PolyMCP introspects regular Python functions and exposes them as MCP tools automatically. No decorators required. No framework lock-in.

It grew into a small ecosystem: • PolyMCP (core) – Turn Python functions into MCP tools • PolyMCP Inspector – A visual UI to browse, test, and debug MCP servers • MCP SDK Apps – A lightweight way to build AI-powered apps with tools + UI resources

Why I built this

While experimenting with MCP and AI agents, I found that integrating existing codebases was often the painful part. Most solutions require rewriting logic around a specific SDK or heavily annotating functions.

PolyMCP focuses on: • Minimal intrusion into existing code • Clean separation between business logic and AI tooling • Easy debugging via a visual inspector

Example use cases • Expose internal APIs or legacy scripts to LLM agents • Automate operational workflows • Build internal copilots over real systems • Prototype AI agents that interact with production services

Works with OpenAI, Anthropic, and Ollama (including local models).

It’s still evolving and I’m actively iterating. I’d really appreciate feedback — especially from people building agents or experimenting with MCP in production environments.

GitHub: • Core: https://github.com/poly-mcp/PolyMCP • Inspector: https://github.com/poly-mcp/PolyMCP-Inspector • SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps

Happy to answer technical questions.

I built PolyMCP, an open-source framework that lets any Python function become an MCP tool usable by AI agents — no rewrites, decorators, or custom SDKs needed.

Features: • Expose Python functions as MCP tools (core framework) • PolyMCP Inspector: visual UI to browse, test, and debug servers • MCP SDK Apps: build full AI-powered apps with tools + UI resources

Real use cases: • Turn existing APIs into AI-callable tools • Automate internal workflows without rewriting legacy code • Build dashboards, copilots, or support tools

Supports LLMs like OpenAI, Anthropic, and Ollama (including local models).

Repo: https://github.com/poly-mcp/PolyMCP Inspector: https://github.com/poly-mcp/PolyMCP-Inspector SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps

Feedback welcome from anyone building AI agents or internal tools!