semvec/pypi-packages huggingface dataset:
llama-index-readers-airbyte-zendesk-support 0.4.1
llama-index readers airbyte_zendesk_support integration
Requires Python: <4.0,>=3.9

# Airbyte ZendeskSupport Loader

```bash
pip install llama-index-readers-airbyte-zendesk-support
```

The Airbyte ZendeskSupport Loader allows you to access different ZendeskSupport objects.

## Usage

Here's an example usage of the AirbyteZendeskSupportReader.

```python
from llama_index.readers.airbyte_zendesk_support import (
    AirbyteZendeskSupportReader,
)

zendesk_support_config = {
    # ...
}
reader = AirbyteZendeskSupportReader(config=zendesk_support_config)
documents = reader.load_data(stream_name="tickets")
```

## Configuration

Check out the [Airbyte documentation page](https://docs.airbyte.com/integrations/sources/zendesk-support/) for details about how to configure the reader.
The JSON schema the config object should adhere to can be found on Github: [https://github.com/airbytehq/airbyte/blob/master/airbyte-integrations/connectors/source-zendesk-support/source_zendesk_support/spec.json](https://github.com/airbytehq/airbyte/blob/master/airbyte-integrations/connectors/source-zendesk-support/source_zendesk_support/spec.json).

The general shape looks like this:

```python
{
    "subdomain": "<your zendesk subdomain>",
    "start_date": "<date from which to start retrieving records from in ISO format, e.g. 2020-10-20T00:00:00Z>",
    "credentials": {
        "credentials": "api_token",
        "email": "<your email>",
        "api_token": "<your api token>",
    },
}
```

By default all fields are stored as metadata in the documents and the text is set to the JSON representation of all the fields. Construct the text of the document by passing a `record_handler` to the reader:

```python
def handle_record(record, id):
    return Document(
        doc_id=id, text=record.data["title"], extra_info=record.data
    )


reader = AirbyteZendeskSupportReader(
    config=zendesk_support_config, record_handler=handle_record
)
```

## Lazy loads

The `reader.load_data` endpoint will collect all documents and return them as a list. If there are a large number of documents, this can cause issues. By using `reader.lazy_load_data` instead, an iterator is returned which can be consumed document by document without the need to keep all documents in memory.

## Incremental loads

This loader supports loading data incrementally (only returning documents that weren't loaded last time or got updated in the meantime):

```python
reader = AirbyteZendeskSupportReader(config={...})
documents = reader.load_data(stream_name="tickets")
current_state = reader.last_state  # can be pickled away or stored otherwise

updated_documents = reader.load_data(
    stream_name="tickets", state=current_state
)  # only loads documents that were updated since last time
```

This loader is designed to be used as a way to load data into [LlamaIndex](https://github.com/run-llama/llama_index/).
kilm 0.5.4
A command-line tool for managing KiCad libraries across projects and workstations
Requires Python: >=3.9
Keywords: cli, eda, electronics, kicad, library-management, pcb-design

# KiCad Library Manager (KiLM)

[![PyPI version](https://img.shields.io/pypi/v/kilm.svg)](https://pypi.org/project/kilm/)
[![Python versions](https://img.shields.io/pypi/pyversions/kilm.svg)](https://pypi.org/project/kilm/)
[![PyPI Downloads](https://static.pepy.tech/badge/kilm)](https://pepy.tech/projects/kilm)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
[![Documentation](https://img.shields.io/badge/docs-website-brightgreen.svg)](https://kilm.aristovnik.me)

Professional command-line tool for managing KiCad libraries across projects and workstations.

**[Official Documentation](https://kilm.aristovnik.me)**

## Features

- Automatically detect KiCad configurations across different platforms (Windows, macOS, Linux)
- Add symbol and footprint libraries to KiCad from a centralized repository
- Set environment variables directly in KiCad configuration
- Pin favorite libraries for quick access in KiCad
- Create timestamped backups of configuration files
- Support for environment variables
- Dry-run mode to preview changes
- Compatible with KiCad 6.x and newer
- Project template management to standardize new designs

## Quick Start

```bash
# Install (recommended)
pipx install kilm

# Verify installation
kilm --version

# Initialize a library
kilm init --name my-library --description "My KiCad components"

# Set up KiCad to use your libraries
kilm setup

# Check current configuration
kilm status
```

> **[Complete Installation Guide](https://kilm.aristovnik.me/guides/installation/)** - Multiple installation methods, verification steps, and troubleshooting.

## Documentation

**[Complete Documentation](https://kilm.aristovnik.me)**

| Guide | Description |
|-------|-------------|
| [Getting Started](https://kilm.aristovnik.me/guides/getting-started/) | Creator and consumer workflows with Git integration |
| [Configuration](https://kilm.aristovnik.me/guides/configuration/) | KiLM and KiCad configuration management |
| [CLI Reference](https://kilm.aristovnik.me/reference/cli/) | Complete command documentation with examples |
| [Development](https://kilm.aristovnik.me/community/development/) | Setup guide for contributors and development |

## License

[MIT License](LICENSE)

## Contributing

Contributions are welcome! See our comprehensive guides:

- **[Contributing Guidelines](https://kilm.aristovnik.me/community/contributing/)** - Issue reporting, pull requests, coding standards
- **[Development Setup](https://kilm.aristovnik.me/community/development/)** - Local development environment and tools

**Quick Start for Contributors:**
```bash
git clone https://github.com/barisgit/kilm.git
cd kilm
pip install -e ".[dev]"
pytest  # Run all tests
```
llama-index-llms-alibabacloud-aisearch 0.3.1
llama-index llms alibabacloud_aisearch integration
Requires Python: <4.0,>=3.9

# LlamaIndex Llms Integration: Alibabacloud_Aisearch

## Installation

```
pip install llama-index-llms-alibabacloud-aisearch
```

## Usage

For further details, please visit [text-generation-api-details](https://help.aliyun.com/zh/open-search/search-platform/developer-reference/text-generation-api-details).

You can specify the `endpoint` and `aisearch_api_key` in the constructor, or set the environment variables `AISEARCH_ENDPOINT` and `AISEARCH_API_KEY`.

```python
from llama_index.llms.alibabacloud_aisearch import AlibabaCloudAISearchLLM
from llama_index.core import ChatPromptTemplate

llm = AlibabaCloudAISearchLLM(service_id="ops-qwen-turbo")
prompt_template = ChatPromptTemplate.from_messages(
    [("system", "You are helpful assistant."), ("user", "{prompt}")]
)
messages = prompt_template.format_messages(prompt="<your question>")
print(llm.chat(messages))
```
llama-index-readers-openalex 0.4.1
llama-index readers openalex integration
Requires Python: <4.0,>=3.9
Keywords: academic papers, open access, openalex, scientific papers

# OpenAlex Reader

```bash
pip install llama-index-readers-openalex
```

This loader will search for papers in OpenAlex and load them in llama-index. The main advantage of using OpenAlex is that you can search the full-text for Open Access papers as well.

## Usage

```python
from llama_index.readers.openalex import OpenAlexReader

openalex_reader = OpenAlexReader(email="shauryr@gmail.com")
query = "biases in large language models"

# changing this to full_text=True will let you search full-text
documents = openalex_reader.load_data(query, full_text=False)
```

## What can it do?

As shown in [demo.ipynb](demo.ipynb) we can get answers with citations.

```python
query = "biases in large language models"
response = query_engine.query(
    "list the biases in large language models in a markdown table"
)
```

#### Output

| Source    | Biases                                                                                           |
| --------- | ------------------------------------------------------------------------------------------------ |
| Source 1  | Data selection bias, social bias (gender, age, sexual orientation, ethnicity, religion, culture) |
| Source 2  | Biases of what is right and wrong to do, reflecting ethical and moral norms of society           |
| Source 3  | Anti-Muslim bias                                                                                 |
| Source 6  | Gender bias                                                                                      |
| Source 9  | Anti-LGBTQ+ bias                                                                                 |
| Source 10 | Potential bias in the output                                                                     |

## Credits

- OpenAlex API details are listed [here](https://docs.openalex.org/how-to-use-the-api/get-lists-of-entities/search-entities)

- Some code adopted from [pyAlex](https://github.com/J535D165/pyalex/blob/435287ac20d84ca047e84c71e2c32a6bb84f61a1/pyalex/api.py#L95)
llama-index-multi-modal-llms-nebius 0.5.1
llama-index multi-modal-llms nebius ai studio integration
Requires Python: <4.0,>=3.9

# LlamaIndex Llms Integration: [Nebius AI Studio](https://studio.nebius.ai/)

## Overview

This project integrates Nebius AI Studio API into multimodal language models of the LlamaIndex framework.

## Installation

```bash
pip install llama-index-multi-modal-llms-nebius
```

## Usage

### Initialization

#### With environmental variables.

```.env
NEBIUS_API_KEY=your_api_key

```

```python
from llama_index.multi_modal_llms.nebius import NebiusMultiModal

llm = NebiusLLM(model="Qwen/Qwen2-VL-72B-Instruct-base")
```

#### Without environmental variables

```python
from llama_index.multi_modal_llms.nebius import NebiusMultiModal

llm = NebiusLLM(
    api_key="your_api_key", model="Qwen/Qwen2-VL-72B-Instruct-base"
)
```

### Launching

#### Load images

```python
from llama_index.core.multi_modal_llms.generic_utils import load_image_urls

image_urls = [
    "https://res.cloudinary.com/hello-tickets/image/upload/c_limit,f_auto,q_auto,w_1920/v1640835927/o3pfl41q7m5bj8jardk0.jpg",
]
image_documents = load_image_urls(image_urls)
```

#### Call `complete` with a prompt

```python
complete_response = mm_llm.complete(
    prompt="Describe the images as an alternative text",
    image_documents=image_documents,
)
```

#### Stream `complete`

```python
stream_complete_response = mm_llm.stream_complete(
    prompt="give me more context for this image",
    image_documents=image_documents,
)
for r in stream_complete_response:
    print(r.delta, end="")
```
llama-index-readers-alibabacloud-aisearch 0.3.1
llama-index readers alibabacloud_aisearch integration
Requires Python: <4.0,>=3.9

# LlamaIndex Readers Integration: Alibabacloud_Aisearch

## Installation

```
pip install llama-index-readers-alibabacloud-aisearch
```

## Usage

Supported file types: ppt/pptx, doc/docx, pdf, images and so on.
For further details, please visit:

- [document-analyze-api-details](https://help.aliyun.com/zh/open-search/search-platform/developer-reference/api-details)
- [image-analyze-api-details](https://help.aliyun.com/zh/open-search/search-platform/developer-reference/opensearch-api-details)

You can specify the `endpoint` and `aisearch_api_key` in the constructor, or set the environment variables `AISEARCH_ENDPOINT` and `AISEARCH_API_KEY`.

### Read local files

```python
from llama_index.readers.alibabacloud_aisearch import (
    AlibabaCloudAISearchDocumentReader,
    AlibabaCloudAISearchImageReader,
)
from llama_index.core import SimpleDirectoryReader

document_reader = AlibabaCloudAISearchDocumentReader()
image_reader = AlibabaCloudAISearchImageReader()

file_extractor = {}
for suffix in (".pdf", ".docx", ".doc", ".ppt", ".pptx"):
    file_extractor[suffix] = document_reader
for suffix in (".jpg", ".jpeg", ".png", ".bmp", ".tiff"):
    file_extractor[suffix] = image_reader

documents = SimpleDirectoryReader(
    "./data", file_extractor=file_extractor
).load_data(show_progress=True)
print(documents)
```

### Read remote files

```python
from llama_index.readers.alibabacloud_aisearch import (
    AlibabaCloudAISearchImageReader,
)

image_reader = AlibabaCloudAISearchImageReader(
    service_id="ops-image-analyze-ocr-001"
)
image_urls = [
    "https://img.alicdn.com/imgextra/i1/O1CN01WksnF41hlhBFsXDNB_!!6000000004318-0-tps-1000-1400.jpg",
]

# The file_type is automatically determined based on the file extension.
# If it cannot be identified, manual specification of the file_type is required.
documents = image_reader.load_data(file_path=image_urls, file_type="jpg")
print(documents)
```
llama-index-llms-cometapi 0.1.1
llama-index llms cometapi integration
Requires Python: <4.0,>=3.9

# LlamaIndex LLM Integration: CometAPI

## Installation

To install the required packages, run:

```bash
pip install llama-index-llms-cometapi
```

## Setup

### Get API Key

1. Visit [CometAPI Console](https://api.cometapi.com/console/token)
2. Sign up for an account (If you don't already have a CometAPI account)
3. Generate your API key

### Initialize CometAPI

You can set the API key either as an environment variable `COMETAPI_API_KEY` or pass it directly:

```python
from llama_index.llms.cometapi import CometAPI

# Method 1: Using environment variable
# export COMETAPI_API_KEY="your-api-key"
llm = CometAPI(model="gpt-4o-mini")

# Method 2: Direct API key
llm = CometAPI(
    api_key="your-api-key",
    model="gpt-4o-mini",
    max_tokens=256,
    context_window=4096,
)
```

## Usage Examples

### Generate Chat Responses

```python
from llama_index.core.llms import ChatMessage

message = ChatMessage(role="user", content="Tell me a joke")
resp = llm.chat([message])
print(resp)
```

### Streaming Chat

```python
message = ChatMessage(role="user", content="Tell me a story")
resp = llm.stream_chat([message])
for r in resp:
    print(r.delta, end="")
```

### Text Completion

```python
resp = llm.complete("Tell me a joke")
print(resp)
```

### Streaming Completion

```python
resp = llm.stream_complete("Tell me a story")
for r in resp:
    print(r.delta, end="")
```

## Available Models

CometAPI supports various state-of-the-art models:

### GPT Series

- `gpt-5-chat-latest`
- `chatgpt-4o-latest`
- `gpt-5-mini`
- `gpt-4o-mini`
- `gpt-4.1-mini`

### Claude Series

- `claude-opus-4-1-20250805`
- `claude-sonnet-4-20250514`
- `claude-3-5-haiku-latest`

### Gemini Series

- `gemini-2.5-pro`
- `gemini-2.5-flash`
- `gemini-2.0-flash`

### Others

- `deepseek-v3.1`
- `grok-4-0709`
- `qwen3-30b-a3b`

For complete list, visit: https://api.cometapi.com/pricing

## Model Configuration

```python
# Use different models
llm_claude = CometAPI(model="claude-3-5-haiku-latest")
llm_gemini = CometAPI(model="gemini-2.5-flash")
llm_deepseek = CometAPI(model="deepseek-v3.1")

response = llm_claude.complete("Explain quantum computing")
print(response)
```

## Documentation

- [CometAPI Website](https://www.cometapi.com/)
- [API Documentation](https://api.cometapi.com/doc)
- [Model Pricing](https://api.cometapi.com/pricing)
llama-index-readers-spotify 0.4.1
llama-index readers spotify integration
Requires Python: <4.0,>=3.9
Keywords: music, spotify

# Spotify Loader

```bash
pip install llama-index-readers-spotify
```

This loader reads your Spotify account and loads saved albums, tracks, or playlists into `Documents`.

As a prerequisite, you will need to register with [Spotify for Developers](https://developer.spotify.com) and create an app in order to get a `client_id` and a `client_secret`. You should then set a `redirect_uri` for the app (in the web dashboard under app settings). The `redirect_uri` does not need to be functional. You should then set the `client_id`, `client_secret`, and `redirect_uri` as environmental variables.

`export SPOTIPY_CLIENT_ID='xxxxxxxxxxxxxxxxx'`\
`export SPOTIPY_CLIENT_SECRET='xxxxxxxxxxxxxxxxxx'`\
`export SPOTIPY_REDIRECT_URI='http://localhost:8080/redirect'`

## Usage

Here's an example usage of the SpotifyReader. It will retrieve your saved albums, unless an optional `collection` argument is passed. Acceptable arguments are "albums", "tracks", and "playlists".

```python
from llama_index.readers.spotify import SpotifyReader

loader = SpotifyReader()
documents = loader.load_data()
```

## Example

This loader is designed to be used as a way to load data into [LlamaIndex](https://github.com/run-llama/llama_index/).

### LlamaIndex

```python
from llama_index.core import VectorStoreIndex, download_loader

from llama_index.readers.spotify import SpotifyReader

loader = SpotifyReader()
documents = loader.load_data()
index = VectorStoreIndex.from_documents(documents)
index.query(
    "When are some other artists i might like based on what i listen to ?"
)
```
llama-index-readers-jaguar 0.4.1
llama-index readers jaguar integration
Requires Python: <4.0,>=3.9

# LlamaIndex Readers Integration: Jaguar

## Overview

Jaguar Reader retrieves documents from an existing persisted Jaguar store. These documents can then be used in a downstream LlamaIndex data structure.

### Installation

You can install Jaguar Reader via pip:

```bash
pip install llama-index-readers-jaguar
```

To use Jaguar Reader, you must have an API key. Here are the [installation instructions](http://www.jaguardb.com/docsetup.html)

## Usage

```python
from llama_index.readers.jaguar import JaguarReader

# Initialize JaguarReader
reader = JaguarReader(
    pod="<Pod Name>",
    store="<Store Name>",
    vector_index="<Vector Index Name>",
    vector_type="<Vector Type>",
    vector_dimension="<Vector Dimension>",
    url="<Endpoint URL>",
)

# Login to Jaguar server
reader.login(jaguar_api_key="<Jaguar API Key>")

# Load data from Jaguar
documents = reader.load_data(
    embedding="<Embedding Vector>",
    k=10,
    metadata_fields=["<Metadata Field 1>", "<Metadata Field 2>"],
    where="<Query Condition>",
)

# Logout from Jaguar server
reader.logout()
```

This loader is designed to be used as a way to load data into
[LlamaIndex](https://github.com/run-llama/llama_index/tree/main/llama_index).
llama-index-postprocessor-pinecone-native-rerank 0.2.1
llama-index postprocessor reranker models from pinecone cloud service
Requires Python: <4.0,>=3.9

# LLamaIndex node postprocessing reranker using pinecone hosted models

- use rerank models with the pinecone managed vector service to rerank the search results
- available rerank models from [pinecone](https://app.pinecone.io/organizations/-Nn577_974iRsvC6nVxg/projects/a4fe57a4-b1cc-4a99-bf1d-c35a595cae4a/models)

```python
import os
from llama_index.core import VectorStoreIndex
from llama_index.core.schema import TextNode
from llama_index.postprocessor.pinecone_native_rerank import (
    PineconeNativeRerank,
)
from llama_index.core.response.pprint_utils import pprint_response

os.environ["PINECONE_API_KEY"] = "your_pinecone_api_key"
os.environ["OPENAI_API_KEY"] = "your_openai_api_key"

txts = [
    "Apple is a popular fruit known for its sweetness and crisp texture.",
    "Apple is known for its innovative products like the iPhone.",
    "Many people enjoy eating apples as a healthy snack.",
    "Apple Inc. has revolutionized the tech industry with its sleek designs and user-friendly interfaces.",
    "An apple a day keeps the doctor away, as the saying goes.",
    "apple has a lot of vitamins",
]

nodes = [TextNode(id_=f"vec{i}", text=txt) for i, txt in enumerate(txts)]

pinecone_reranker = PineconeNativeRerank(top_n=4, model="pinecone-rerank-v0")

index = VectorStoreIndex(nodes)

query_engine = index.as_query_engine(
    similarity_top_k=10,
    node_postprocessors=[pinecone_reranker],
)

response = query_engine.query(
    "The tech company Apple is known for its innovative products like the iPhone."
)

pprint_response(response, show_source=True)
```

output

```txt
Final Response: Apple is recognized for its innovative products like
the iPhone.
______________________________________________________________________
Source Node 1/4
Node ID: vec1
Similarity: 0.9655668
Text: Apple is known for its innovative products like the iPhone.
______________________________________________________________________
Source Node 2/4
Node ID: vec3
Similarity: 0.55420566
Text: Apple Inc. has revolutionized the tech industry with its sleek
designs and user-friendly interfaces.
______________________________________________________________________
Source Node 3/4
Node ID: vec4
Similarity: 0.3172258
Text: An apple a day keeps the doctor away, as the saying goes.
______________________________________________________________________
Source Node 4/4
Node ID: vec0
Similarity: 0.25139993
Text: Apple is a popular fruit known for its sweetness and crisp
texture.

```
llama-index-llms-gigachat-ru 0.4.1
llama-index llms gigachat integration
Requires Python: <4.0,>=3.9

# LlamaIndex Llms Integration: Gigachat

This package provides a Gigachat integration as LLM Module.

## Installation

using poetry:

```shell
poetry add llama-index-llms-gigachat-ru
```

or using pip:

```shell
pip install llama-index-llms-gigachat-ru
```

## Basic Usage

To initialize the Gigachat integration, you need to provide the `credentials`
and optionally set `verify_ssl_certs` to `False`
if you want to disable SSL certificate verification.

Then you will be able to use the `complete` method to get the completion.

```python
from llama_index.llms.gigachat import GigaChatLLM

llm = GigaChatLLM(
    credentials="NjI0M2M4MzctNmEwMi00ZjhmLWIzYmEtMTBlMzdhZjI4NzNhOjgzYjM3YzFkLWQ3MTEtNGVhYi04Y2Q0LTkwODM5ZjI4MDg1Zg==",
    verify_ssl_certs=False,
)
resp = llm.complete("What is the capital of France?")
print(resp)
```

Also, you can use it asynchronously:

```python
import asyncio
from llama_index.llms.gigachat import GigaChatLLM

llm = GigaChatLLM(
    credentials="NjI0M2M4MzctNmEwMi00ZjhmLWIzYmEtMTBlMzdhZjI4NzNhOjgzYjM3YzFkLWQ3MTEtNGVhYi04Y2Q0LTkwODM5ZjI4MDg1Zg==",
    verify_ssl_certs=False,
)


async def main():
    resp = await llm.acomplete("What is the capital of France?")
    print(resp)


asyncio.run(main())
```

And as a chat module:

```python
import asyncio

from llama_index.core.chat_engine import SimpleChatEngine
from llama_index.llms.gigachat import GigaChatLLM

llm = GigaChatLLM(
    credentials="NjI0M2M4MzctNmEwMi00ZjhmLWIzYmEtMTBlMzdhZjI4NzNhOjgzYjM3YzFkLWQ3MTEtNGVhYi04Y2Q0LTkwODM5ZjI4MDg1Zg==",
    verify_ssl_certs=False,
)

chat = SimpleChatEngine.from_defaults(
    llm=llm,
)


async def main():
    resp = await chat.achat("What is the capital of France?")
    print(resp)


asyncio.run(main())
```

And as streaming completion:

```python
import asyncio

from llama_index.llms.gigachat import GigaChatLLM

llm = GigaChatLLM(
    credentials="NjI0M2M4MzctNmEwMi00ZjhmLWIzYmEtMTBlMzdhZjI4NzNhOjgzYjM3YzFkLWQ3MTEtNGVhYi04Y2Q0LTkwODM5ZjI4MDg1Zg==",
    verify_ssl_certs=False,
)


async def main():
    async for resp in await llm.astream_complete(
        "What is the capital of France?"
    ):
        print(resp)


asyncio.run(main())
```
llama-index-readers-faiss 0.4.1
llama-index readers faiss integration
Requires Python: <4.0,>=3.9

# LlamaIndex Readers Integration: Faiss

## Overview

Faiss Reader retrieves documents through an existing in-memory Faiss index. These documents can then be used in a downstream LlamaIndex data structure. If you wish to use Faiss itself as an index to organize documents, insert documents, and perform queries on them, please use VectorStoreIndex with FaissVectorStore.

### Installation

You can install Faiss Reader via pip:

```bash
pip install llama-index-readers-faiss
```

## Usage

```python
from llama_index.readers.faiss import FaissReader

# Initialize FaissReader with an existing Faiss Index object
reader = FaissReader(index="<Faiss Index Object>")

# Load data from Faiss
documents = reader.load_data(
    query="<Query Vector>",  # 2D numpy array of query vectors
    id_to_text_map={"<ID>": "<Text>"},  # A map from IDs to text
    k=4,  # Number of nearest neighbors to retrieve
    separate_documents=True,  # Whether to return separate documents
)
```

This loader is designed to be used as a way to load data into
[LlamaIndex](https://github.com/run-llama/llama_index/tree/main/llama_index).