semvec/pypi-packages huggingface dataset:
iflow-mcp_emacs-mcp-server 0.1.0
Model Context Protocol (MCP) server for Emacs
Requires Python: >=3.12

# Emacs MCP Server

Model Context Protocol (MCP) server for Emacs. Enables generating and running elisp code in a running Emacs process.

## Tools

The server exposes two tools:
- `generate_emacs_lisp_code`: generates elisp for a given task
- `execute_emacs_lisp_code`: passes elisp to a running Emacs (via `emacsclient`) to eval and execute it.

## Invocation

The project is managed with `uv`. First, run `uv sync` to install all dependencies. Then `source .venv/bin/activate` to activate the resulting venv.

To run the MCP server in the inspector:

```sh
mcp dev emacs_mcp_server.py
```

To install the MCP server so that Claude Desktop can use it:

```sh
mcp install emacs_mcp_server.py
```

But you will have to edit the resulting JSON config in `claude_desktop_config.json` to include API keys and the full path to `emacsclient`. It should look something like this:

```json
    "Emacs-MCP-Server": {
      "command": "/Users/haldar/.local/bin/uv",
      "args": [
        "run",
        "--with",
        "mcp[cli]",
        "--with",
        "smartfunc",
        "mcp",
        "run",
        "/Users/haldar/repos/gh/emacs-mcp-server/emacs_mcp_server.py"
      ],
      "env": {
          "OPENAI_API_KEY": "sk-xxxx",
          "EMACSCLIENT": "/your/path/to/emacsclient"
      }
    }
```
pypsql 1.0.1
Functionality to connect and interact with PostgreSQL servers
Requires Python: >=3.8

# pypSQL


<a href="https://www.marius-liebald.com/pypsql/index.html" style="float:right; margin-left:10px;">
<img src="docs/source/_static/img/pypsql_logo_dark.png" style="height:139px !important; width:auto !important;" alt="pypsql utilities website" />
</a>

<!-- badges: start -->

![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
<!-- badges: end -->

`pypsql` is a lightweight framework for connecting to PostgreSQL
databases, whether locally or remotely hosted. It builds on top of
[`SQLAlchemy`](https://www.sqlalchemy.org/) to provide a simple,
Pythonic interface for establishing connections, running queries, and
managing database sessions.

# Contributors

[Marius Liebald](https://www.marius-liebald.de) (maintainer)

# Installation

``` bash
pip install pypsql
```

# Basic Usage

## Provide database credentials

You can store the database connection details in a file, for example:

``` python
SERVER=<host name or address>   # e.g., localhost, 127.0.0.1, or a public IP
PORT=<port number>              # default: 5432
NAME_DATABASE=<database name>   # e.g., my_db
NAME_USER=<role>                # e.g., Alice
PASSWORD_USER=<password>        # e.g., 123abc
```

You may place this file anywhere on the client machine. Importantly,
this step is optional. You can also provide the variables interactively
via terminal prompts.

## No SSH required

An SSH tunnel is not needed if:

- the server and client run on the same machine,
- the server and client are in the same (virtual) network, or
- the server is accessible via its public IP.

In this case, simply run the Python script:

``` python
import pypsql
from pathlib import Path

conn = pypsql.DatabaseConnector(
    path=Path(<path to the credential file>), # e.g., "/Users/marius/Desktop/" # if the .env file is located in the same directory as the script you are executing, you can leave this argument undefined
    db_credential_file=<name of credential file>   # e.g., ".env" (default) or "credentials.py"
)

sql_script = """
SELECT *
FROM customers
"""

df = conn.get_data(sql_script)

print(df)
```

Note that this example assumes the database contains a table named
`customers`.

## Connection via SSH

To be filled.

# Official Documentation

The documentation is hosted under
<https://www.marius-liebald.com/pypsql/index.html>

# License

The package is distributed under the [MIT license](LICENSE.txt).

# References

<div id="refs" class="references csl-bib-body hanging-indent"
entry-spacing="0">

<div id="ref-sqlalchemy2025" class="csl-entry">

Bayer, Michael, and contributors. 2025. “SQLAlchemy.”
<https://www.sqlalchemy.org/>.

</div>

</div>
iflow-mcp_mcp-server-data-wrangler 0.1.0
Add your description here
Requires Python: >=3.11.8

# mcp-data-wrangler: MCP server for Data Wrangling

## Overview

This is a Model Context Protocol server for Data Wrangling, providing a standardized interface for data preprocessing, transformation, and analysis tasks. It enables seamless integration of data wrangling operations into the MCP ecosystem.

## Features

* Data aggregation
* Descriptive statistics

## Run this project locally

This project is not yet set up for ephemeral environments (e.g. `uvx` usage). Run this project locally by cloning this repo:

```bash
git clone https://github.com/yourusername/mcp-data-wrangler.git
cd mcp-data-wrangler
```

You can launch the MCP inspector via npm:

```bash
npx @modelcontextprotocol/inspector uv --directory=src/mcp_data_wrangler run mcp-data-wrangler
```

Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.

OR Add this tool as a MCP server:

```json
{
  "data-wrangler": {
    "command": "uv",
    "args": [
      "--directory",
      "/path/to/mcp-data-wrangler",
      "run",
      "mcp-data-wrangler"
    ]
  }
}
```

## Development

1. Create and activate a virtual environment:

```bash
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
```

2. Install dependencies:

```bash
pip install -e ".[dev]"
```

3. Run tests:

```bash
pytest -s -v tests/
```

## [License](LICENSE)
iflow-mcp_mcp-server-zenn 0.1.0
Add your description here
Requires Python: >=3.11.8

# mcp-server-zenn: Unofficial MCP server for Zenn (https://zenn.dev/)

## Overview

This is an unofficial Model Context Protocol server for [Zenn](https://zenn.dev/). Build on top of [Zenn's dev API](https://zenn.dev/api/).

## Features

- Fetch a list of articles
- Fetch a list of books

## Run this project locally

This project is not yet set up for ephemeral environments (e.g. `uvx` usage). Run this project locally by cloning this repo:

```shell
git clone https://github.com/shibuiwilliam/mcp-server-zenn.git
```

You can launch the [MCP inspector](https://github.com/modelcontextprotocol/inspector) via [npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm):

```shell
npx @modelcontextprotocol/inspector uv --directory=src/mcp_server_zenn run mcp-server-zenn
```

Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.


OR
Add this tool as a MCP server:

```json
{
  "zenn": {
    "command": "uv",
    "args": [
      "--directory",
      "/path/to/mcp-server-zenn",
      "run",
      "mcp-server-zenn"
    ]
  }
}
```

## Deployment

(TODO)

## [License](./LICENSE)
iflow-mcp_crypto-orderbook-mcp 0.1.0
Add your description here
Requires Python: >=3.10

# Crypto Orderbook MCP

An MCP server that analyzes order book depth and imbalance across major crypto exchanges, empowering AI agents and trading systems with real-time market structure insights.

![License](https://img.shields.io/badge/license-MIT-green)
![Python](https://img.shields.io/badge/python-3.10%2B-blue)
![Status](https://img.shields.io/badge/status-active-brightgreen.svg)


## Features

- **Order Book Metrics**: Calculate bid/ask depth and imbalance for a specified trading pair on a given exchange.
- **Cross-Exchange Comparison**: Compare order book depth and imbalance across multiple exchanges in a unified Markdown table.
- **Supported Exchanges**: Binance, Kraken, Coinbase, Bitfinex, Okx, Bybit

## Installation

### Prerequisites

- Python 3.10 or higher
- [uv](https://github.com/astral-sh/uv) (Python package and project manager)

### Setup

1. **Clone the Repository**

   ```bash
   git clone https://github.com/kukapay/crypto-orderbook-mcp.git
   cd crypto-orderbook-mcp
   ```

2. **Install Dependencies**

   Use `uv` to install the required packages:

   ```bash
   uv sync
   ```
   
3. **Configure the MCP Client(Claude Desktop)**

    ```
    "mcpServers": { 
      "crypto-orderbook-mcp": { 
        "command": "uv", 
        "args": [ "--directory", "/absolute/path/to/crypto-orderbook-mcp", "run", "main.py" ]
      } 
    }
    ```

## Usage

The server provides two main tools:

1. **`calculate_orderbook`**: Computes bid depth, ask depth, and imbalance for a trading pair on a specified exchange.
2. **`compare_orderbook`**: Compares bid depth, ask depth, and imbalance across multiple exchanges, returning a Markdown table.

### Example: Calculate Order Book Metrics

**Prompt**: "Calculate the order book metrics for BTC/USDT on Binance with a 1% depth range."

**Expected Output** (JSON object):

```json
{
  "exchange": "binance",
  "symbol": "BTC/USDT",
  "bid_depth": 123.45,
  "ask_depth": 234.56,
  "imbalance": 0.1234,
  "mid_price": 50000.0,
  "timestamp": 1698765432000
}
```

### Example: Compare Order Book Across Exchanges

**Prompt**: "Compare the order book metrics for BTC/USDT across Binance, Kraken, and OKX with a 1% depth range."

**Expected Output** (Markdown table):

```markdown
| exchange | bid_depth | ask_depth | imbalance |
|----------|-----------|-----------|-----------|
| binance  |    123.45 |    234.56 |    0.1234 |
| kraken   |     89.12 |    178.34 |    0.0987 |
| okx      |    145.67 |    256.78 |    0.1345 |
```

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.