semvec/pypi-packages huggingface dataset:
streamsight 3.1.7
A toolkit for offline evaluation of Recommender Systems.
Requires Python: >=3.13
Keywords: recsys, recommendation, practical evaluation, global timeline, reccomender systems, data leakage

# Streamsight

![streamsight-logo](https://github.com/HiIAmTzeKean/streamsight/raw/master/docs/assets/_static/logo_name.png)

[![PyPI Latest Release](https://img.shields.io/pypi/v/streamsight.svg)](https://pypi.org/project/streamsight/)&nbsp;&nbsp;
[![Docs](https://github.com/hiiamtzekean/streamsight/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/hiiamtzekean/streamsight/)&nbsp;&nbsp;
[![Python version](https://img.shields.io/badge/python-3.12.5-blue)](https://www.python.org/downloads/)

Streamsight is an offline Reccomender Systems (RecSys) evaluation toolkit that respects a global timeline.
The aim is to partition the data into different windows where data is incrementally released for the programmer
to fit, train and submit predictions. This aims to provide a close simulation of an online setting when evaluating
RecSys algorithms.

## Getting Started

Clone the repository

```bash
git clone https://github.com/hiiamtzekean/streamsight
cd streamsight
```

Dependencies can be installed with `uv` for ease of management.

```bash
uv sync
```

Alternatively, you may install dependencies locally with pip and venv

```bash
python3 -m venv venv
source venv/bin/activate
pip install -e .
```

The dependencies are listed in `pyproject.toml`.

## Contributing

- We welcome all contributors, be it reporting an [issue](https://github.com/hiiamtzekean/streamsight/issues),
or raising a [pull request](https://github.com/hiiamtzekean/streamsight/pulls) to fix an issue.
- When you make changes, rerun `pip install .` to test your changes.

## Documentation

The documentation can be found [here](https://hiiamtzekean.github.io/streamsight/)
and [repository](https://github.com/hiiamtzekean/streamsight) on Github.

## Citation

If you use this library in any part of your work, please cite the following papers:

```text
Ng, T. K. (2024). Streamsight: a toolkit for offline evaluation of recommender systems. Final Year Project (FYP), Nanyang Technological University, Singapore. https://hdl.handle.net/10356/181114
```
otel-analyzer-mcp 0.1.1
MCP server for analyzing OpenTelemetry traces
Requires Python: >=3.11
Keywords: mcp, model-context-protocol, observability, opentelemetry, traces, xray

# OTEL Analyzer MCP Server

MCP server for analyzing OpenTelemetry traces with performance and error diagnosis.

## Features

- Load traces from files, strings, AWS X-Ray, or CloudWatch GenAI observability
- Auto-detect format (OTLP JSON, Jaeger, Protobuf, X-Ray)
- Performance analysis: latency breakdown, slow spans, critical path
- Error analysis: error detection, exception extraction, context
- GenAI trace analysis: Bedrock AgentCore, token usage, model latency
- MCP sampling for LLM-assisted deep analysis

## Installation

```bash
uv tool install otel-analyzer-mcp
```

Or for development:

```bash
uv sync
```

## Usage

Run the server:

```bash
otel-analyzer-mcp
```

Or add to your MCP client config:

```json
{
  "mcpServers": {
    "otel-analyzer-mcp": {
      "command": "otel-analyzer-mcp"
    }
  }
}
```

## Tools

| Tool | Description |
|------|-------------|
| `load_trace` | Load from file, JSON, X-Ray trace ID, or CloudWatch |
| `search_xray` | Search X-Ray with filter expressions |
| `search_genai_traces` | Search CloudWatch aws/spans for GenAI traces |
| `list_traces` | List all loaded traces |
| `analyze_perf` | Performance analysis (latency, slow spans, critical path) |
| `analyze_errs` | Error analysis (errors, exceptions, context) |
| `summarize_trace` | High-level trace overview |
| `deep_analyze` | LLM-assisted analysis via MCP sampling |

## Examples

Load a trace file:

```text
load_trace(path="/path/to/trace.json")
```

Search X-Ray:

```text
search_xray(filter_expression='service("my-api") AND responseTime > 5', region="us-east-1")
```

Search GenAI traces:

```text
search_genai_traces(filter_query='name like /bedrock/', region="us-east-1")
```

Load from CloudWatch:

```text
load_trace(trace_id="abc123", source="cloudwatch", region="us-east-1")
```

Analyze performance:

```text
analyze_perf(trace_id="abc123")
```

## License

MIT
iflow-mcp_tcsavage_obsidian-index 0.1.1
An MCP server that provides a semantic search over an Obsidian vault
Requires Python: >=3.11

# Obsidian Index MCP server

An MCP server that provides a semantic search over an Obsidian vault and exposes recent notes as resources.

## Components

### Resources

The server exposes recently modified notes in your vaults as resources to MCP clients.
- Notes are addressed by an `obsidian://<VAULT_NAME>/<NOTE_PATH>` URL scheme
- Notes have the `text/markdown` media type

### Tools

The server implements one tool:
- `search-notes`: Performs semantic search over indexed notes

## Run the server

```bash
uv run obsidian-index mcp --vault <VAULT_PATH> --database <DATABASE_PATH> --reindex --watch
```

- `--vault`: Path to the Obsidian vault (can be specified multiple times)
- `--database`: Path to the local database file (will be created if it doesn't exist)
- `--reindex`: Reindex all notes in the vault (you probably want this every time right now)
- `--watch`: Watch for changes in the vault and update the index accordingly

## 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": {
    "obsidian-index": {
      "command": "uv",
      "args": [
        "--directory",
        "<PATH_TO_PROJECT>",
        "run",
        "obsidian-index",
        "--database",
        "<PATH_TO_DATABASE>",
        "--vault",
        "<PATH_TO_VAULT>",
        "--reindex",
        "--watch"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "obsidian-index": {
      "command": "uvx",
      "args": [
        "obsidian-index",
        "--database",
        "<PATH_TO_DATABASE>",
        "--vault",
        "<PATH_TO_VAULT>",
        "--reindex",
        "--watch"
      ]
    }
  }
  ```
</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 <PATH_TO_PROJECT> run obsidian-index
```


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