* **Model :** Model name from the HuggingFace Hub – defaults to `zephyr-7b-beta`.
**Code snippet**
from beyondllm.llms import HuggingFaceHubModel
llm = HuggingFaceHubModel(model="huggingfaceh4/zephyr-7b-alpha",token="<replace_with_your_token>",model_kwargs={"max_new_tokens":512,"temperature":0.1})
Specify the model name from the HuggingFaceHub and add your token and start using it.
### GroqModel
Groq, a powerful language model API offering access to various chat models, excels at delivering exceptional speed, quality, and energy efficiency compared to traditional methods. If faster LLM inference is a priority, Groq is an excellent choice.
**Installation**
In order to use GroqModel, we first need to install it:
pip install groq
**Parameters**
* **Groq API Key**: Obtain your Groq API key from the Groq console () and set it up as an environment variable for security. This key authenticates your requests with the Groq API.
* **Model** (Required):Specifies the Groq language model to use.
* **Optional Parameters**:
* temperature: Controls the response randomness (lower for predictable, higher for creative).
#### Code Snippet
```python
import os
from getpass import getpass
os.environ['GROQ_API_KEY'] = getpass("Enter your Groq API key securely: ")
from beyondllm.llms import GroqModel
llm = GroqModel(
model_name=model,
groq_api_key=os.getenv('GROQ_API_KEY'),
temperature=0 )
```
This code retrieves your Groq API key securely, creates a GroqModel instance with the specified model\_name and retrieved API key, sets an optional temperature parameter, and demonstrates how to use the generate method for text generation. Remember to replace model with the actual Groq model name you want to use.
### Claude Model
The `ClaudeModel` class represents a language model from Anthropic. This model can be integrated into the OpenAGI framework to utilize its capabilities in generating textual responses. Below is the detailed implementation and explanation of the `ClaudeModel`.pip install ollama
**Installation**
```python
pip install anthropic
```
**Parameters**
* **Anthropic API Key**: Obtain your Anthropic API key from the Anthropic console and set it up as an environment variable for security. This key authenticates your requests with the Anthropic API.
* **Model (Required)**: Specifies the Claude language model to use, such as `claude-3-5-sonnet-20240620`.
**Optional Parameters:**
* **temperature**: Controls the response randomness (lower for predictable, higher for creative).
* **top\_p**: Controls the nucleus sampling, representing the cumulative probability of parameter highest probability tokens.
* **top\_k**: Limits the sampling pool to the top `k` tokens.
* **max\_tokens**: Specifies the maximum number of tokens in the generated response.
#### Code Snippet
```python
import os
from getpass import getpass
from beyondllm.llms import ClaudeModel
os.environ['ANTHROPIC_API_KEY'] = getpass("Enter your Anthropic API key securely: ")
llm = ClaudeModel(
model="claude-3-5-sonnet-20240620",
model_kwargs={"max_tokens": 512, "temperature": 0.1}
)
#
#or
#llm = ClaudeModel(model="claude-3-5-sonnet-20240620",api_key=os.getenv('ANTHROPIC_API_KEY'),
# model_kwargs={"max_tokens": 512, "temperature": 0.1}
#)
```
### Ollama
Ollama lets you run models locally and use them in your application.
In order to get started with Ollama, we first need to download it, and pull the model based on our need. Download Ollama:
**Basic Ollama Commands**
```bash
ollama pull llama2 # loads llama2 model locally
ollama pull gemma # loads gemma mdoel locally
ollama list # displays all the models that are installed
```
More commands:
**Installation**
```bash
pip install ollama
```
**Parameters**
* **Model** : The name of the model you are using.
**Code snippet**
Make sure, before you run the OllamaModel, the model is running locally on your terminal. `ollama run llama2`
```python
from beyondllm.llms import OllamaModel
llm = OllamaModel(model="llama2")
```
### AzureOpenAIModel
Azure OpenAI Service provides REST API access to OpenAI’s powerful language models including the `GPT-4`, `GPT-3.5-Turbo`, and `Embeddings model` series.
**Installation**
In order to use AzureOpenAIModel, we first need to install it:
```bash
pip install openai
```
**Parameters**
* **AzureChatOpenAI API Key:** Azure api key for AzureChatOpenAI service.
* **Deployment Name :** Enter the the deployment name that is created on Model deployments on Azure
* **Endpoint Url :** Enter your endpoint url.
* **Model Name :** AzureChatOpenAI enables the access to GPT4 models.
* **Max Tokens :** The maximum sequence length for the model response.
* **Temperature :** It can be used to control the randomness or creativity in responses.
> Create your Azure account and get Endpoint URL and Key from here:
**Code snippet**
```python
from beyondllm.llms import AzureOpenAIModel
llm = AzureOpenAIModel(model="gpt4",api_key = "",deployment_name="",endpoint_url="",model_kwargs={"max_tokens":512,"temperature":0.1})
```
### **MistralModel**
The MistralModel utilizes Mistral AI's robust capabilities, offering support for both text and multimodal inputs. It allows users to send text prompts alongside images for enhanced interaction, making it a versatile choice for BeyondLLM users. This model handles complex requests while ensuring flexibility in configuration. It is particularly useful for use cases requiring the combination of text and visual content.
**Notes**: Ensure you have installed the Mistral AI library and obtained an API key for authentication. The model supports various customization parameters such as `max_tokens` and `temperature`.
**Parameters**
* **Mistral API Key**: Required for authenticating and accessing the Mistral API.
* **Model Name**: Defines the Mistral model to be used, e.g., `mistral-large`.
* **Model Parameters**: Optional parameters like `max_tokens`, `temperature` to fine-tune the model's response behavior.
**Code snippet**
```python
from beyondllm.llms import MistralModel
llm = MistralModel(model_name="mistral-large", api_key="", model_kwargs={"max_tokens": 512, "temperature": 0.7})
print(llm.predict("", image_path=""))
```
Import the MistralModel, configure it with your API key and model parameters, and start generating responses with support for multimodal inputs.
[^1]: