README.md

---
base_model:
- meta-llama/Llama-3.2-1B-Instruct
language:
- en
license: apache-2.0
tags:
- text-generation-inference
- transformers
- unsloth
- llama
- trl
- Ollama
- Tool-Calling
datasets:
- hiyouga/glaive-function-calling-v2-sharegpt
---
# Function Calling Llama Model

## Overview
A specialized fine-tuned version of the `meta-llama/Llama-3.2-1B-Instruct` model enhanced with function/tool calling capabilities. The model leverages the **hiyouga/glaive-function-calling-v2-sharegpt** dataset for training.

## Model Specifications

* **Base Architecture**: meta-llama/Llama-3.2-1B-Instruct
* **Primary Language**: English (Function/Tool Calling), Vietnamese
* **Licensing**: Apache 2.0
* **Primary Developer**: nguyenthanhthuan_banhmi
* **Key Capabilities**: text-generation-inference, transformers, unsloth, llama, trl, Ollama, Tool-Calling

## Getting Started

### Prerequisites

1. Install [Ollama](https://ollama.com/)
2. Install required Python packages:
   ```bash
   pip install langchain pydantic torch langchain-ollama
   ```

### Installation Steps

1. Clone the repository
2. Navigate to the project directory
3. Create the model in Ollama:
   ```bash
   ollama create <model_name> -f <path_to_modelfile>
   ```

## Implementation Guide

### Model Initialization

```python
from langchain_ollama import ChatOllama 

# Initialize model instance
llm = ChatOllama(model="<model_name>")
```

### Basic Usage Example

```python
# Arithmetic computation example
query = "What is 3 * 12? Also, what is 11 + 49?"
response = llm.invoke(query)

print(response.content)
# Output:
# 1. 3 times 12 is 36.
# 2. 11 plus 49 is 60.
```

### Advanced Function Calling (English Recommended)

#### Basic Arithmetic Tools
```python
from pydantic import BaseModel, Field

class add(BaseModel):
    """Addition operation for two integers."""
    a: int = Field(..., description="First integer")
    b: int = Field(..., description="Second integer")

class multiply(BaseModel):
    """Multiplication operation for two integers."""
    a: int = Field(..., description="First integer")
    b: int = Field(..., description="Second integer")

# Tool registration
tools = [add, multiply]
llm_tools = llm.bind_tools(tools)

# Execute query
response = llm_tools.invoke(query)
print(response.content)
# Output:
# {"type":"function","function":{"name":"multiply","arguments":[{"a":3,"b":12}]}}
# {"type":"function","function":{"name":"add","arguments":[{"a":11,"b":49}}]}}
```

#### Complex Tool Integration

```python
from pydantic import BaseModel, Field
from typing import List, Optional

class SendEmail(BaseModel):
    """Email dispatch functionality."""
    to: List[str] = Field(..., description="List of email recipients")
    subject: str = Field(..., description="Email subject")
    body: str = Field(..., description="Email content/body")
    cc: Optional[List[str]] = Field(None, description="CC recipients")
    attachments: Optional[List[str]] = Field(None, description="List of attachment file paths")

class WeatherInfo(BaseModel):
    """Weather information retrieval."""
    city: str = Field(..., description="City name")
    country: Optional[str] = Field(None, description="Country name")
    units: str = Field("celsius", description="Temperature units (celsius/fahrenheit)")

class SearchWeb(BaseModel):
    """Web search functionality."""
    query: str = Field(..., description="Search query")
    num_results: int = Field(5, description="Number of results to return")
    language: str = Field("en", description="Search language")

class CreateCalendarEvent(BaseModel):
    """Calendar event creation."""
    title: str = Field(..., description="Event title")
    start_time: str = Field(..., description="Event start time (ISO format)")
    end_time: str = Field(..., description="Event end time (ISO format)")
    description: Optional[str] = Field(None, description="Event description")
    attendees: Optional[List[str]] = Field(None, description="List of attendee emails")

# Tool integration
tools = [SendEmail, WeatherInfo, SearchWeb, CreateCalendarEvent]
llm_tools = llm.bind_tools(tools)

# Example usage
query = "Set a reminder to call John at 3 PM tomorrow. Also, translate 'Hello, how are you?' to Spanish."
print(llm_tools.invoke(query).content)
# Output:
# {"type":"function","function":{"name":"SetReminder","arguments":{"message":"Call John at 3 PM tomorrow"},"arguments":{"time":"","priority":"normal"}}}
# {"type":"function","function":{"name":"TranslateText","arguments":{"text":"Hello, how are you?", "source_lang":"en", "target_lang":"es"}}
```

## Core Features

* Arithmetic computation support
* Advanced function/tool calling capabilities
* Seamless Langchain integration
* Full Ollama platform compatibility

## Technical Details

### Dataset Information
Training utilized the `hiyouga/glaive-function-calling-v2-sharegpt` dataset, featuring comprehensive function calling interaction examples.

### Known Limitations

* Basic function/tool calling
* English language support exclusively
* Ollama installation dependency

## Important Notes & Considerations

### Potential Limitations and Edge Cases

* **Function Parameter Sensitivity**: The model may occasionally misinterpret complex parameter combinations, especially when multiple optional parameters are involved. Double-check parameter values in critical applications.

* **Response Format Variations**:
  - In some cases, the function calling format might deviate from the expected JSON structure
  - The model may generate additional explanatory text alongside the function call
  - Multiple function calls in a single query might not always be processed in the expected order

* **Error Handling Considerations**:
  - Empty or null values might not be handled consistently across different function types
  - Complex nested objects may sometimes be flattened unexpectedly
  - Array inputs might occasionally be processed as single values

### Best Practices for Reliability

1. **Input Validation**:
   - Always validate input parameters before processing
   - Implement proper error handling for malformed function calls
   - Consider adding default values for optional parameters

2. **Testing Recommendations**:
   - Test with various input combinations and edge cases
   - Implement retry logic for inconsistent responses
   - Log and monitor function call patterns for debugging

3. **Performance Optimization**:
   - Keep function descriptions concise and clear
   - Limit the number of simultaneous function calls
   - Cache frequently used function results when possible

### Known Issues

* Model may struggle with:
  - Very long function descriptions
  - Highly complex nested parameter structures
  - Ambiguous or overlapping function purposes
  - Non-English parameter values or descriptions

## Development

### Contributing Guidelines
We welcome contributions through issues and pull requests for improvements and bug fixes.

### License Information
Released under Apache 2.0 license. See LICENSE file for complete terms.

## Academic Citation

```bibtex
@misc{function-calling-llama,
    author = {nguyenthanhthuan_banhmi},
    title = {Function Calling Llama Model},
    year = {2024},
    publisher = {GitHub},
    journal = {GitHub repository}
}
```