semvec/pypi-packages huggingface dataset:
gravilab 0.1.4
Package to analyze seismic data based on obspy and spicypy packages.
Requires Python: <3.14,>=3.8

# GraviLab

Package to analyze seismic data based on [obspy](obspy.org) and [spicypy](https://gitlab.com/pyda-group/spicypy) packages.

## Installation

```bash
pip install gravilab
```

## Usage

The main element of the package is [`Seismometer`](https://gitlab.com/pyda-group/gravilab/-/blob/main/gravilab/base/seismometer.py) class, which represents a seismic instrument.
It can be created by loading seismic data with `open` function and specifying channels,
both their names in the file and "human-readable" names. The folder is then scanned for any suitable data
and only those channels are loaded. All functionality related to seismic time series data is
provided by the underlying [obspy](obspy.org) package (specifically [`obspy.Trace`](https://docs.obspy.org/packages/autogen/obspy.core.trace.Trace.html)).

[`Seismometer`](https://gitlab.com/pyda-group/gravilab/-/blob/main/gravilab/base/seismometer.py) class also supports calculating spectrum
(`Seismometer.asd()`, `Seismometer.psd()`) using [spicypy](https://gitlab.com/pyda-group/spicypy) package.
Spectrum can be adjusted by the response of specific instrument specified by pole-zero model,
and units can be converted between displacement, velocity
and acceleration by specifying the `omega` factor. Resulting spectrum is [`spicypy.FrequencySeries`](https://pyda-group.gitlab.io/spicypy/autoapi/spicypy/signal/frequency_series/index.html). Additionally,
time series can also be converted to [`spicypy.TimeSeries`](https://pyda-group.gitlab.io/spicypy/autoapi/spicypy/signal/time_series/index.html) to profit from its rich signal processing functionality.

Minimal example:
```python
import gravilab as gl
Seismometer1 = gl.open("seismic", channels = {"vertical":"HNZ","north":"HNY","east":"HNX"}, name="seismometer1")
Seismometer1.time_series["north"].plot()
response = {"poles" : [-0.036614 +0.037059j, -0.036614 -0.037059j, -32.55, -142, -364 +404j, -364 -404j, -1260, -4900 +5200j, -4900 -5200j, -7100 +1700j, -7100 -1700j],
            "zeros" : [0, 0, -31.63, -160, -350, -3177],
            "scale_factor" : 1202.5 * 8.31871e17 * 400000, #V/(m/s) times gain times counts/V
            "omega_exponent": -1, #convert from m/s to m
           }
Seismometer1.response = response
Seismometer1.asd()["north"].plot()
```

More detailed usage examples are provided in [gravilab/examples](https://gitlab.com/pyda-group/gravilab/-/tree/main/examples) folder.
bot-engine 0.2.5
The universal bot engine framework. Made on top of pytelegrambotapi
Requires Python: >=3.12

The universal bot engine framework. Made on top of pytelegrambotapi

# Starting your development journey

## Step 1. .env file example

Example of ready-to-work .env file:
```
ENVIRONMENT=development
PORT=8000

BOT_TOKEN=your_token
MONGODB_TOKEN=your_token

ADMIN_IDS=1,2
SUPER_ADMIN_ID=1
```

### Accessing .env data

You can import all this variables from bot_engine.data.env file. 
There you will see ready-to-use constants loaded right from your .env file.


## Step 2. First users! (optional)

You can easily create initial users in your DB by doing this:

1. Create folder "data" with a file "initials_users.py". Place an array of initial users with dictionaries:

INITIAL_USERS = 
[
    {
        "real_name": "Valeriy",
        "id": 123,
        "access_level": "user" or "admin",
        "any_other_data": any,
    },
    ...
]

Then call method Database().add_users(INITIAL_USERS) to fill your DB with initial users. This is an optional one-time operation for setting up your first users in DB. That's simple!


### A data security minute

You can leave the file "initials_users.py" in your project. Just add it to .gitignore to prevent the leakout of the data.


## Step 3. Run the bot

Call Bot().start() to start bot. It handles all .env file data automatically using data/env.py file - no need to import / load your .env data
balkongas 0.1.2
A Python package for interacting with the balkongas API.
Requires Python: >=3.7

# BalkonGas Python

A small library to interact with the BalkonGas API for a reactor. It allows you to get the latest values for a reactor.


## 📦 Installation

```sh
pip install balkongas
```

## 🚀 Quick start

In this example, we create a reactor based on the data from this URL https://api.balkongas.de/metrics/6f1d3382-6b95-4adc-9d6f-6785ae0456f3/json/latest/


```python
from balkongas import Reactor
r = Reactor('6f1d3382-6b95-4adc-9d6f-6785ae0456f3')
r.refresh()
print(r.data["uptime_sec"])
```


## 🚀 Development

### 1️⃣ Setup a Local Development Environment

1. **Clone the repository**
   ```sh
   git clone https://github.com/balkongas/BalkonGas-Python.git
   cd balkongas
   ```
2. **Create a virtual environment**
   ```sh
   python -m venv .venv
   ```
3. **Activate the virtual environment**
   - **macOS/Linux:**
     ```sh
     source .venv/bin/activate
     ```
   - **Windows (CMD):**
     ```sh
     .venv\Scripts\activate
     ```
   - **Windows (PowerShell):**
     ```sh
     .venv\Scripts\Activate.ps1
     ```
4. **Install dependencies**
   ```sh
   pip install -e .[dev]
   ```

### 2️⃣ Running Tests
To run tests using `pytest`, use:
```sh
pytest
```

### 3️⃣ Building the Package
To build the package, run:
```sh
python -m build
```
This will generate a `dist/` directory with `.tar.gz` and `.whl` files.

### 4️⃣ Uploading to PyPI
1. **Ensure you have Twine installed**
   ```sh
   pip install twine
   ```
2. **Upload the package**
   ```sh
   twine upload dist/*
   ```
3. **Verify installation from PyPI**
   ```sh
   pip install balkongas
   ```

---

Now you're ready to develop, test, and distribute `balkongas`! 🚀
todo-mcp 0.1.0
A MCP server project
Requires Python: >=3.12

# todo-mcp MCP server

A MCP server project

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single prompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "todo-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "/workspace/supabase-demo/todo-mcp",
        "run",
        "todo-mcp"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "todo-mcp": {
      "command": "uvx",
      "args": [
        "todo-mcp"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory /workspace/supabase-demo/todo-mcp run todo-mcp
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
orange1-employee 0.1.0
Add your description here
Requires Python: >=3.6

# Build a MCP Server 
A complete walkthrough on how to build a MCP server to serve a trained Random Forest model and integrate it with Bee Framework for ReAct interactivity.

## See it live and in action 📺
<a href="https://www.linkedin.com/posts/nicholasrenotte_mcp-servers-make-tools-a-bunch-easier-for-activity-7305748751162163200-dIEn?utm_source=share&utm_medium=member_desktop&rcm=ACoAABbxZgUBrud9C531KZPQHCs2riXCiv9Av2A"><img src="https://i.imgur.com/Y2LN9dd.png"/></a>

# Startup MCP Server 🚀
1. Clone this repo `git clone https://github.com/nicknochnack/BuildMCPServer`
2. To run the MCP server\
`cd BuildMCPServer`\
`uv venv`\
`source .venv/bin/activate`\
`uv add .`\
`uv add ".[dev]"`\
`uv run mcp dev server.py`
3. To run the agent, in a separate terminal, run:\
`source .venv/bin/activate`\
`uv run singleflowagent.py`

# Startup FastAPI Hosted ML Server 
`git clone https://github.com/nicknochnack/CodeThat-FastML`\
`cd CodeThat-FastML`\
`pip install -r requirements.txt`\
`uvicorn mlapi:app --reload`\
Detailed instructions on how to build it can also be found <a href="https://youtu.be/C82lT9cWQiA?si=dIsL6eM1lUMAVcf0">here</a></br>


# Other References 🔗 </br>
- <a href="https://github.com/RGGH/mcp-client-x/blob/main/src/client/mcp_client.py">Building MCP Clients (used in singleflow agent)</a></br>
- <a href="https://www.youtube.com/watch?v=C82lT9cWQiA&t=1003s ">Original Video where I build the ML server</a>


# Who, When, Why?
👨🏾‍💻 Author: Nick Renotte <br />
📅 Version: 1.x<br />
📜 License: This project is licensed under the MIT License </br>
orange1-bitable-mcp 0.2.1
This MCP server provides access to Lark bitable through the Model Context Protocol.
Requires Python: >=3.10

# Bitable MCP Server

This MCP server provides access to Lark Bitable through the Model Context Protocol. It allows users to interact with Bitable tables using predefined tools.

## One click installation & Configuration

### Claude 

To install and configure the server, use the following command:
```bash
PERSONAL_BASE_TOKEN=your_personal_base_token APP_TOKEN=your_app_token uv run --with uv --with bitable-mcp bitable-mcp-install
```
Replace `your_personal_base_token` and `your_app_token` with your actual tokens.

### Cursor
Coming soon

### Windsurf
Coming soon

## Available Tools

- `list_table` - List tables for the current Bitable.
  - **Returns**: A JSON-encoded list of table names.

- `describe_table` - Describe a table by its name.
  - **Parameters**:
    - `name` (str): The name of the table to describe.
  - **Returns**: A JSON-encoded list of columns in the table.

- `read_query` - Execute a SQL query to read data from the tables.
  - **Parameters**:
    - `sql` (str): The SQL query to execute.
  - **Returns**: A JSON-encoded list of query results.

## Manual installation and configuration

Please make sure `uvx` is installed before installation.

Add to your Claude settings:

1. Using uvx

```json
"mcpServers": {
  "bitable-mcp": {
    "command": "uvx",
    "args": ["bitable-mcp"],
    "env": {
        "PERSONAL_BASE_TOKEN": "your-personal-base-token",
        "APP_TOKEN": "your-app-token"
    }
  }
}
```

2. Using pip installation

1) Install `bitable-mcp` via pip:

```bash
pip install bitable-mcp
```

2) Modify your Claude settings

```json
"mcpServers": {
  "bitable-mcp": {
    "command": "python",
    "args": ["-m", "bitable_mcp"],
    "env": {
        "PERSONAL_BASE_TOKEN": "your-personal-base-token",
        "APP_TOKEN": "your-app-token"
    }
  }
}
```

### Configure for Zed

Add to your Zed settings.json:

Using uvx

```json
"context_servers": [
  "bitable-mcp": {
    "command": "uvx",
    "args": ["bitable-mcp"],
    "env": {
        "PERSONAL_BASE_TOKEN": "your-personal-base-token",
        "APP_TOKEN": "your-app-token"
    }
  }
],
```

Using pip installation

```json
"context_servers": {
  "bitable-mcp": {
    "command": "python",
    "args": ["-m", "bitable_mcp"],
    "env": {
        "PERSONAL_BASE_TOKEN": "your-personal-base-token",
        "APP_TOKEN": "your-app-token"
    }
  }
},
```

## Debugging

You can use the MCP inspector to debug the server. For uvx installations:

```bash
npx @modelcontextprotocol/inspector uvx bitable-mcp
```
orange1-cryptopanic-mcp-server 0.1.0
Provide the latest cryptocurrency news for AI agents.
Requires Python: >=3.6

# cryptopanic-mcp-server

Provide the latest cryptocurrency news to AI agents, powered by [CryptoPanic](https://cryptopanic.com/).

<a href="https://glama.ai/mcp/servers/dp6kztv7yx">
  <img width="380" height="200" src="https://glama.ai/mcp/servers/dp6kztv7yx/badge" alt="cryptopanic-mcp-server MCP server" />
</a>

## Tools

The server implements only one tool: 

```python
get_crypto_news(kind: str = "news", num_pages: int = 1) -> str
```
- `kind`: Content type (news, analysis, videos)
- `num_pages`: Number of pages to fetch (default: 1, max: 10)

Example Output: 

```
- Bitcoin Breaks $60k Resistance Amid ETF Optimism
- Ethereum Layer 2 Solutions Gain Traction
- New Crypto Regulations Proposed in EU
- ...
```


## Configuration

- CryptoPanic API key: get one [here](https://cryptopanic.com/developers/api/)
- Add a server entry to your configuration file:

```
"mcpServers": { 
  "cryptopanic-mcp-server": { 
    "command": "uv", 
    "args": [ 
      "--directory", "/your/path/to/cryptopanic-mcp-server", 
      "run", 
      "main.py" 
    ], 
    "env": { 
      "CRYPTOPANIC_API_KEY": "" 
    } 
  } 
}
```

## License

MIT License - see `LICENSE` file
orange1-mcp-cube-server 0.0.2
MCP server for interfacing with Cube.dev REST API
Requires Python: >=3.11

# Snowflake Cube Server

[![smithery badge](https://smithery.ai/badge/@isaacwasserman/mcp_cube_server)](https://smithery.ai/server/@isaacwasserman/mcp_cube_server)

MCP Server for Interacting with Cube Semantic Layers

## Resources

### `context://data_description`
Contains a description of the data available in the Cube deployment. This is an application controlled version of the `describe_data` tool.

### `data://{data_id}`
Contains the data returned by a `read_data` call in JSON format. This resource is meant for MCP clients that wish to format or otherwise process the output of tool calls. See [`read_data`](#read_data) for more.

## Tools

### `read_data`
Accepts a query to the Cube REST API and returns the data in YAML along with a unique identifier for the data returned. This identifier can be used to a retrieve a JSON representation of the data from the resource `data://{data_id}`. See [`data://{data_id}`](#datadata_id) for more.

### `describe_data`
Describes the data available in the Cube deployment. This is an agentic version of the `context://data_description` resource.
orange1-mcp-document-reader 0.1.1
A MCP Server for reading PDF and EPUB files.
Requires Python: <4,>=3.11

# mcp-document-reader

A rudimentary [MCP server](https://modelcontextprotocol.io/introduction) for interacting with PDF and EPUB documents.

I use this with [Windsurf IDE by Codeium](https://codeium.com/windsurf), which
only supports MCP tools, not resources.

## Installation

### Requirements

- [Python 3.11+](https://www.python.org/downloads/)
- [Poetry](https://python-poetry.org/docs/)

```bash
# Clone the repository
git clone https://github.com/jbchouinard/mcp-document-reader.git
cd mcp-document-reader
poetry install
```

## Configure MCP Server

Run with poetry:

```json
{
  "mcpServers": {
    "documents": {
      "command": "poetry",
      "args": ["-C", "path/to/mcp-document-reader", "run", "mcp-document-reader"]
    }
  }
}
```

Alternatively, build and install with pip, then run the script directly:

```bash
poetry build
pipx install dist/*.whl
which mcp-document-reader
```

Then use the following config, with the path output by which:

```json
{
  "mcpServers": {
    "documents": {
      "command": "/path/to/mcp-document-reader",
      "args": []
    }
  }
}
```

## Development

### Setup

```bash
# Install dependencies
poetry install
```

### Testing

```bash
poetry run pytest
```

### Linting

```bash
poetry run ruff check --fix .
poetry run ruff format .
```

## License

[MIT](LICENSE)
orange1-mcp-server-weaviate 0.1.0
Add your description here
Requires Python: >=3.6

# mcp-server-weaviate
[![smithery badge](https://smithery.ai/badge/@weaviate/mcp-server-weaviate)](https://smithery.ai/server/@weaviate/mcp-server-weaviate)

MCP server for Weaviate

## 🏎️ Quickstart

### Prerequisites

- Ensure you have `uv` installed (see
  [the docs](https://docs.astral.sh/uv/getting-started/installation/) for
  details)
- Clone this repository

### Install

#### Installing via Smithery

To install Weaviate MCP Server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@weaviate/mcp-server-weaviate):

```bash
npx -y @smithery/cli install @weaviate/mcp-server-weaviate --client claude
```

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`

On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

Development/Unpublished Servers Configuration

```
{
  "mcpServers": {
    "mcp-server-weaviate": {
      "command": "PYTHON_PATH",
      "args": [
        "-m",
        "src.server",
        "--weaviate-url",
        "YOUR_WEAVIATE_URL",
        "--weaviate-api-key",
        "YOUR_WEAVIATE_API_KEY",
        "--search-collection-name",
        "YOUR_SEARCH_COLLECTION",
        "--store-collection-name",
        "YOUR_STORE_COLLECTION",
        "--openai-api-key",
        "YOUR_OPENAI_API_KEY"
      ],
      "env": {
        "PYTHONPATH": "PATH_TO_MCP_SERVER_WEAVIATE_DIRECTORY"
      }
    }
  }
}
```

![Demo](./test.png)
rssmcp 0.1.1
Simple RSS MCP Server
Requires Python: >=3.10.16

# rssmcp MCP server

Simple RSS MCP Server

## Components

### Tools

The server implements one tool:
- get_rss: Fetches RSS feeds and returns entries as formatted text
  - Takes "feed_name" and "since" as required string arguments
  - "export_result" as an optional boolean parameter (defaults to false)
  - Returns formatted feed entries as text and optionally exports to a file

## Quickstart

### Install

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "rssmcp": {
      "command": "uvx",
      "args": [
        "rssmcp"
      ]
    }
  }
  ```
</details>
docs2llm 0.1.0
CLI tool to generate LLM context from documentation.
Requires Python: >=3.11

# docs2llm

A command-line tool to extract documentation from local directories and GitHub repositories, formatting it for use as context with Large Language Models (LLMs).

## Purpose

docs2llm helps you capture documentation from codebases to use as context for AI assistants and large language models. It searches for documentation files (markdown, text, etc.), processes them, and creates a single consolidated file that can be used as reference material for LLMs.

## Features

- Extract documentation from local directories or GitHub repositories
- Automatically identify and process common documentation files
- Prioritize README files and important documentation
- Support for multiple file formats (Markdown, RST, TXT)
- Format output for optimal LLM context
- Control scan depth to manage output size
- Clone specific branches from Git repositories
- Detailed logging with configurable verbosity

## Installation

```bash
# Install from PyPI
pip install docs2llm

```

## Usage

### Command Line Interface

```bash
# Extract docs from a local directory
docs2llm /path/to/project --output context.txt

# Extract docs from a GitHub repository
docs2llm --git owner/repo --output context.txt

# Specify a branch
docs2llm --git owner/repo --branch develop

# Control scan depth
docs2llm /path/to/project --max-depth 2

# Enable verbose logging
docs2llm /path/to/project -v

# Write logs to a file
docs2llm /path/to/project --log-file extraction.log
```

### Options

- `PATH`: Local directory containing documentation files
- `--git`: GitHub repository URL or owner/repo format
- `--output`: Output file name (default: llm_context.txt)
- `--max-depth`: Maximum directory depth to search (default: 3)
- `--branch`: Specific branch to clone (only used with --git)
- `--verbose`, `-v`: Enable verbose logging
- `--log-file`: Log to this file in addition to console

### Python API

```python
from docs2llm import extract_documentation

# Extract from local directory
success = extract_documentation(
    local_path="/path/to/project",
    output_file="context.txt",
    max_depth=3,
    verbose=True
)

# Extract from GitHub repository
success = extract_documentation(
    git_repo="owner/repo",
    output_file="context.txt",
    branch="main",
    verbose=True
)
```