semvec/pypi-packages huggingface dataset:
searxh 0.1.2
Dependency-free BM25 indexer and search CLI for local code/docs
Requires Python: >=3.9
Keywords: search, bm25, sqlite, cli, indexer

# searxh

Small BM25 search tool for local code/docs. No third-party dependencies.

## what it does

- Indexes text/code files into SQLite (`bm25.sqlite` by default)
- Supports incremental indexing (only changed files are reprocessed)
- Ranks with BM25
- Shows optional snippets with line numbers
- Supports path/extension filters, JSON output, and colored matches

## requirements

- Python 3.9+

## install

Editable install:

```bash
python3 -m pip install -e .
```

After install, use:

```bash
searxh index .
searxh "replication backlog"
sx index .
sx "replication backlog"
```

## quick start

Build or update index:

```bash
./search index .
```

Check whether the current directory is indexed:

```bash
./search status
```

Search:

```bash
./search "replication backlog"
```

## command forms

```bash
./search [global-options] index [root] [index-options]
./search [global-options] search "query"
./search [global-options] "query"
```

## common examples

Full rebuild:

```bash
./search index . --full
```

Search with snippet + color:

```bash
./search --snippet --color "aof fsync"
```

Filter by path:

```bash
./search --path src/ "replication"
```

Filter by extension:

```bash
./search --ext .c,.h,.md "dict"
```

JSON output:

```bash
./search --json "cluster slots"
```

Custom index path:

```bash
./search index . --out /path/to/myindex.sqlite
./search --index /path/to/myindex.sqlite "term"
```

## key options

- `--k`: number of results (default `10`)
- `--k1`, `--b`: BM25 tuning knobs
- `--path-boost`: extra weight for path token matches (default `1.5`)
- `--stem`: enable simple stemming
- `--no-stopwords`: disable stopword filtering
- `--workers`: indexing worker threads
- `--no-progress`: hide indexing progress output

## indexing behavior

1. Scan files by extension/name and skip likely binary files.
2. Compare `mtime` and `size` with index metadata.
3. Reindex changed files and remove deleted files.
4. Update postings and document metadata in SQLite.

If a file produces no tokens (for example, empty/whitespace-only), it is saved as a zero-length doc so incremental runs do not keep retrying it.

## tests

```bash
python3 -m unittest discover -s . -p 'test_*.py' -q
```

## troubleshooting

`sqlite3.OperationalError: unable to open database file`
- Make sure the DB parent directory exists and is writable.
- Try writing the DB in the current project first:
```bash
./search index . --out ./bm25.sqlite
```

Results look weak
- Rebuild with `--full`
- Try `--stem`
- Increase `--k`
- Recheck filters (`--ext`, `--path`)

## files

- `src/sx_search/cli.py`: CLI
- `src/sx_search/engine.py`: indexing/search engine
- `search`: compatibility wrapper script
- `bm25tool.py`: compatibility import wrapper
- `test_bm25tool.py`: tests
- `SEARCH.md`: short usage notes
ezmsg-sigproc 2.17.0
Timeseries signal processing implementations in ezmsg
Requires Python: >=3.10

# ezmsg-sigproc

Signal processing primitives for the [ezmsg](https://www.ezmsg.org) message-passing framework.

## Features

* **Filtering** - Chebyshev, comb filters, and more
* **Spectral analysis** - Spectrogram, spectrum, and wavelet transforms
* **Resampling** - Downsample, decimate, and resample operations
* **Windowing** - Sliding windows and buffering utilities
* **Math operations** - Arithmetic, log, abs, difference, and more
* **Signal generation** - Synthetic signal generators
* More! Brows the API documentation for more details.

All modules use [`AxisArray`](https://www.ezmsg.org/ezmsg/reference/API/axisarray.html) as the primary data structure for passing signals between components. The default data backend is NumPy, but other backends are supported via the Array API such as CuPy and MLX.

## Installation

Install from PyPI:

```bash
pip install ezmsg-sigproc
```

Or install from GitHub for the latest development version:

```bash
pip install git+https://github.com/ezmsg-org/ezmsg-sigproc.git@dev
```

## Documentation

Full documentation is available at [ezmsg.org](https://www.ezmsg.org).

## Development

We use [`uv`](https://docs.astral.sh/uv/) for development.

1. Fork and clone the repository
2. `uv sync` to create a virtual environment and install dependencies
3. `uv run pre-commit install` to set up linting and formatting hooks
4. `uv run pytest tests` to run the test suite
5. Submit a PR against the `dev` branch
iflow-mcp_lethain-systems-mcp 0.1.1
Add your description here
Requires Python: >=3.11

# systems-mcp

[systems-mcp](https://github.com/lethain/systems-mcp) is an MCP server for interacting with
the [`lethain:systems`](https://github.com/lethain/systems/) library for systems modeling.

It provides two tools:

* `run_systems_model` runs the `systems` specification of a systems model.
    Takes two parameters, the specification and, optionally, the number of
    rounds to run the model (defaulting to 100).
* `load_systems_documentation` loads documentation and examples into the context window.
    This is useful for priming models to be more helpful at writing systems models.

It is intended for running locally in conjunction with Claude Desktop or a similar tool.

## Usage


Here's an example of using `systems-mcp` to run and render a model.

![Example of prompt for  using systems-mcp](docs/systems-mcp-prompt.png)

Here is the artifact generated from that prompt, including the output from
running the systems model.

![Example of artifact for using the output of systems-mcp](docs/systems-mcp-artifact.png)

Finally, here is an example of using the `load_systems_documentation` tool to prime
the context window and using it to help generate a systems specification.
This is loosely equivalent to including [`lethain:systems/README.md`](https://raw.githubusercontent.com/lethain/systems/refs/heads/master/README.md) in the context window,
but also includes a handful of additional examples
(see the included files in [./docs/](./docs/).

![Example prompt of loading documentation into context window](docs/sys-mcp-load-prompt.png)

Then you can render the model as before.

![Example prompt of rendering the generated model](docs/sys-mcp-load-artifact.png)

The most interesting piece here is that I've never personally used `systems` to model a social network,
but the LLM was able to do a remarkably decent job at generating a specification despite that.


## Installation

These instructions describe installation for [Claude Desktop](https://claude.ai/download) on OS X.
It should work similarly on other platforms.

1. Install [Claude Desktop](https://claude.ai/download).
2. Clone [systems-mcp](https://github.com/lethain/systems-mcp) into
    a convenient location, I'm assuming `/Users/will/systems-mcp`
3. Make sure you have `uv` installed, you can [follow these instructions](https://modelcontextprotocol.io/quickstart/server)
4. Go to Cladue Desktop, Setting, Developer, and have it create your MCP config file.
    Then you want to update your `claude_desktop_config.json`.
    (Note that you should replace `will` with your user, e.g. the output of `whoami`.

        cd  ~/Library/Application\ Support/Claude/
        vi claude_desktop_config.json

    Then add this section:

        {
          "mcpServers": {
            "systems": {
              "command": "uv",
              "args": [
                "--directory",
                "/Users/will/systems-mcp",
                "run",
                "main.py"
              ]
            }
          }
        }

5. Close Claude and reopen it.
6. It should work...
iflow-mcp_unibaseio-membase-mcp 0.1.0
Add your description here
Requires Python: >=3.10

# membase mcp server

## Description

Membase is the first decentralized memory layer for AI agents, powered by Unibase. It provides secure, persistent storage for conversation history, interaction records, and knowledge — ensuring agent continuity, personalization, and traceability.

The Membase-MCP Server enables seamless integration with the Membase protocol, allowing agents to upload and retrieve memory from the Unibase DA network for decentralized, verifiable storage.

## Functions

Messages or memoiries can be visit at: <https://testnet.hub.membase.io/>

- **get_conversation_id**: Get the current conversation id.
- **switch_conversation**: Switch to a different conversation.
- **save_message**: Save a message/memory into the current conversation.
- **get_messages**: Get the last n messages from the current conversation.

## Installation

```shell
git clone https://github.com/unibaseio/membase-mcp.git
cd membase-mcp
uv run src/membase_mcp/server.py
```

## Environment variables

- MEMBASE_ACCOUNT: your account to upload
- MEMBASE_CONVERSATION_ID: your conversation id, should be unique, will preload its history
- MEMBASE_ID: your instance id

## Configuration on Claude/Windsurf/Cursor/Cline

```json
{
  "mcpServers": {
    "membase": {
      "command": "uv",
      "args": [
        "--directory",
        "path/to/membase-mcp",
        "run", 
        "src/membase_mcp/server.py"
      ],
      "env": {
        "MEMBASE_ACCOUNT": "your account, 0x...",
        "MEMBASE_CONVERSATION_ID": "your conversation id, should be unique",
        "MEMBASE_ID": "your sub account, any string"
      }
    }
  }
}
```

## Usage

call functions in llm chat

- get conversation id and switch conversation

![get conversation id and switch conversation](./asset/switch.png)

- save message and get messages

![save message and get messages](./asset/save.png)