semvec/pypi-packages huggingface dataset:
gigachain-together 0.1.5
An integration package connecting Together AI and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-together

This package contains the LangChain integrations for [Together AI](https://www.together.ai/) through their [APIs](https://docs.together.ai/).

## Installation and Setup

- Install the LangChain partner package

```bash
pip install -U langchain-together
```

- Get your Together AI api key from the [Together Dashboard](https://api.together.ai/settings/api-keys) and set it as an environment variable (`TOGETHER_API_KEY`)

## Chat Completions

This package contains the `ChatTogether` class, which is the recommended way to interface with Together AI chat models.

ADD USAGE EXAMPLE HERE.
Can we add this in the langchain docs?

NEED to add image endpoint + completions endpoint as well

## Embeddings

See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/together/)

Use `togethercomputer/m2-bert-80M-8k-retrieval` as the default model for embeddings.
gigachain-robocorp 0.0.10
An integration package connecting Robocorp Action Server and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-robocorp

| Note: this package is deprecated in favor of the renamed `langchain-sema4` package ([repo](https://github.com/langchain-ai/langchain-sema4), [package](https://pypi.org/project/langchain-sema4/)). |
|-|

This package contains the LangChain integrations for [Robocorp Action Server](https://github.com/robocorp/robocorp).
Action Server enables an agent to execute actions in the real world. 

## Installation

```bash
pip install -U langchain-robocorp
```

## Action Server Toolkit

See [ActionServerToolkit](https://python.langchain.com/docs/integrations/toolkits/robocorp) for detailed documentation.
gigachain-qdrant 0.1.3
An integration package connecting Qdrant and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-qdrant

This package contains the LangChain integration with [Qdrant](https://qdrant.tech/).

## Installation

```bash
pip install -U langchain-qdrant
```

## Usage

The `Qdrant` class exposes the connection to the Qdrant vector store.

```python
from langchain_qdrant import Qdrant

embeddings = ... # use a LangChain Embeddings class

vectorstore = Qdrant.from_existing_collection(
    embeddings=embeddings,
    collection_name="<COLLECTION_NAME>",
    url="http://localhost:6333",
)
```
gigachain-pinecone 0.1.3
An integration package connecting Pinecone and GigaChain
License: MIT
Requires Python: <3.13,>=3.8.1

# langchain-pinecone

This package contains the LangChain integration with Pinecone.

## Installation

```bash
pip install -U langchain-pinecone
```

And you should configure credentials by setting the following environment variables:

- `PINECONE_API_KEY`
- `PINECONE_INDEX_NAME`

## Usage

The `PineconeVectorStore` class exposes the connection to the Pinecone vector store.

```python
from langchain_pinecone import PineconeVectorStore

embeddings = ... # use a LangChain Embeddings class

vectorstore = PineconeVectorStore(embeddings=embeddings)
```
gigachain-ollama 0.1.1
An integration package connecting Ollama and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-ollama

This package contains the LangChain integration with Ollama

## Installation

```bash
pip install -U langchain-ollama
```

You will also need to run the Ollama server locally. 
You can download it [here](https://ollama.com/download).

## Chat Models

`ChatOllama` class exposes chat models from Ollama.

```python
from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3-groq-tool-use")
llm.invoke("Sing a ballad of LangChain.")
```

## Embeddings

`OllamaEmbeddings` class exposes embeddings from Ollama.

```python
from langchain_ollama import OllamaEmbeddings

embeddings = OllamaEmbeddings(model="llama3")
embeddings.embed_query("What is the meaning of life?")
```

## LLMs
`OllamaLLM` class exposes LLMs from Ollama.

```python
from langchain_ollama import OllamaLLM

llm = OllamaLLM(model="llama3")
llm.invoke("The meaning of life is")
```
gigachain-mistralai 0.1.12
An integration package connecting Mistral and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-mistralai

This package contains the LangChain integrations for [MistralAI](https://docs.mistral.ai) through their [mistralai](https://pypi.org/project/mistralai/) SDK.

## Installation

```bash
pip install -U langchain-mistralai
```

## Chat Models

This package contains the `ChatMistralAI` class, which is the recommended way to interface with MistralAI models.

To use, install the requirements, and configure your environment.

```bash
export MISTRAL_API_KEY=your-api-key
```

Then initialize

```python
from langchain_core.messages import HumanMessage
from langchain_mistralai.chat_models import ChatMistralAI

chat = ChatMistralAI(model="mistral-small")
messages = [HumanMessage(content="say a brief hello")]
chat.invoke(messages)
```

`ChatMistralAI` also supports async and streaming functionality:

```python
# For async...
await chat.ainvoke(messages)

# For streaming...
for chunk in chat.stream(messages):
    print(chunk.content, end="", flush=True)
```

## Embeddings

With `MistralAIEmbeddings`, you can directly use the default model 'mistral-embed', or set a different one if available.

### Choose model

`embedding.model = 'mistral-embed'`

### Simple query

`res_query = embedding.embed_query("The test information")`

### Documents

`res_document = embedding.embed_documents(["test1", "another test"])`
gigachain-groq 0.1.9
An integration package connecting Groq and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-groq

## Welcome to Groq! 🚀

At Groq, we've developed the world's first Language Processing Unit™, or LPU. The Groq LPU has a deterministic, single core streaming architecture that sets the standard for GenAI inference speed with predictable and repeatable performance for any given workload.

Beyond the architecture, our software is designed to empower developers like you with the tools you need to create innovative, powerful AI applications. With Groq as your engine, you can:

* Achieve uncompromised low latency and performance for real-time AI and HPC inferences 🔥
* Know the exact performance and compute time for any given workload 🔮
* Take advantage of our cutting-edge technology to stay ahead of the competition 💪

Want more Groq? Check out our [website](https://groq.com) for more resources and join our [Discord community](https://discord.gg/JvNsBDKeCG) to connect with our developers!


## Installation and Setup
Install the integration package:

```bash
pip install gigachain-groq
```

Request an [API key](https://wow.groq.com) and set it as an environment variable

```bash
export GROQ_API_KEY=gsk_...
```

## Chat Model
See a [usage example](https://python.langchain.com/docs/integrations/chat/groq).

## Development

To develop the `langchain-groq` package, you'll need to follow these instructions:

### Install dev dependencies

```bash
poetry install --with test,test_integration,lint,codespell
```

### Build the package

```bash
poetry build
```

### Run unit tests

Unit tests live in `tests/unit_tests` and SHOULD NOT require an internet connection or a valid API KEY.  Run unit tests with

```bash
make tests
```

### Run integration tests

Integration tests live in `tests/integration_tests` and require a connection to the Groq API and a valid API KEY.

```bash
make integration_tests
```

### Lint & Format

Run additional tests and linters to ensure your code is up to standard.

```bash
make lint spell_check check_imports
```
gigachain-fireworks 0.1.7
An integration package connecting Fireworks and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# LangChain-Fireworks

This is the partner package for tying Fireworks.ai and LangChain. Fireworks really strive to provide good support for LangChain use cases, so if you run into any issues please let us know. You can reach out to us [in our Discord channel](https://discord.com/channels/1137072072808472616/)


## Installation

To use the `langchain-fireworks` package, follow these installation steps:

```bash
pip install gigachain-fireworks
```



## Basic usage

### Setting up

1. Sign in to [Fireworks AI](http://fireworks.ai/) to obtain an API Key to access the models, and make sure it is set as the `FIREWORKS_API_KEY` environment variable.

    Once you've signed in and obtained an API key, follow these steps to set the `FIREWORKS_API_KEY` environment variable:
    - **Linux/macOS:** Open your terminal and execute the following command:
    ```bash
    export FIREWORKS_API_KEY='your_api_key'
    ```
    **Note:** To make this environment variable persistent across terminal sessions, add the above line to your `~/.bashrc`, `~/.bash_profile`, or `~/.zshrc` file.

    - **Windows:** For Command Prompt, use:
    ```cmd
    set FIREWORKS_API_KEY=your_api_key
    ```

2. Set up your model using a model id. If the model is not set, the default model is `fireworks-llama-v2-7b-chat`. See the full, most up-to-date model list on [fireworks.ai](https://fireworks.ai/models).

```python
import getpass
import os

# Initialize a Fireworks model
llm = Fireworks(
    model="accounts/fireworks/models/mixtral-8x7b-instruct",
    base_url="https://api.fireworks.ai/inference/v1/completions",
)
```


### Calling the Model Directly

You can call the model directly with string prompts to get completions.

```python
# Single prompt
output = llm.invoke("Who's the best quarterback in the NFL?")
print(output)
```

```python
# Calling multiple prompts
output = llm.generate(
    [
        "Who's the best cricket player in 2016?",
        "Who's the best basketball player in the league?",
    ]
)
print(output.generations)
```





## Advanced usage
### Tool use: LangChain Agent + Fireworks function calling model
Please checkout how to teach Fireworks function calling model to use a [calculator here](https://github.com/fw-ai/cookbook/blob/main/examples/function_calling/fireworks_langchain_tool_usage.ipynb). 

Fireworks focus on delivering the best experience for fast model inference as well as tool use. You can check out [our blog](https://fireworks.ai/blog/firefunction-v1-gpt-4-level-function-calling) for more details on how it fares compares to GPT-4, the punchline is that it is on par with GPT-4 in terms just function calling use cases, but it is way faster and much cheaper.

### RAG: LangChain agent + Fireworks function calling model + MongoDB + Nomic AI embeddings
Please check out the [cookbook here](https://github.com/fw-ai/cookbook/blob/main/examples/rag/mongodb_agent.ipynb) for an end to end flow
gigachain-couchbase 0.1.1
An integration package connecting Couchbase and GigaChain
License: MIT
Requires Python: <4.0,>=3.8.1

# langchain-couchbase

This package contains the LangChain integration with Couchbase

## Installation

```bash
pip install -U langchain-couchbase
```

## Usage

The `CouchbaseVectorStore` class exposes the connection to the Couchbase vector store.

```python
from langchain_couchbase.vectorstores import CouchbaseVectorStore

from couchbase.cluster import Cluster
from couchbase.auth import PasswordAuthenticator
from couchbase.options import ClusterOptions
from datetime import timedelta

auth = PasswordAuthenticator(username, password)
options = ClusterOptions(auth)
connect_string = "couchbases://localhost"
cluster = Cluster(connect_string, options)

# Wait until the cluster is ready for use.
cluster.wait_until_ready(timedelta(seconds=5))

embeddings = OpenAIEmbeddings()

vectorstore = CouchbaseVectorStore(
    cluster=cluster,
    bucket_name="",
    scope_name="",
    collection_name="",
    embedding=embeddings,
    index_name="vector-search-index",
)

```