nguyenthanhthuan/Llama_3.2_1B_Intruct_Tool_Calling_V2

Function Calling Llama Model Version 2

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 nguyenthanhthuan/function-calling-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

Method 1:

1. Install Ollama
2. Install required Python packages:

   pip install langchain pydantic torch langchain-ollama langchain_core
   

Method 2:

1. Click use this model
2. Click Ollama

Installation Steps

1. Clone the repository
2. Navigate to the project directory
3. Create the model in Ollama:

   ollama create <model_name> -f <path_to_modelfile>
   

Implementation Guide

Model Initialization

from langchain_ollama import ChatOllama 

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

Basic Usage Example

# 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 (Different from the first version)

from pydantic import BaseModel

# Note that the docstrings here are crucial, as they will be passed along
# to the model along with the class name.
class add(BaseModel):
    """Add two integers together."""

    a: int = Field(..., description="First integer")
    b: int = Field(..., description="Second integer")

class multiply(BaseModel):
    """Multiply two integers together."""

    a: int = Field(..., description="First integer")
    b: int = Field(..., description="Second integer")

tools = [add, multiply]
llm_with_tools = llm.bind_tools(tools)

# Execute query and parser result (Different from the first version)
from langchain_core.output_parsers.openai_tools import PydanticToolsParser

query = "What is 3 * 12? Also, what is 11 + 49?"
chain = llm_with_tools | PydanticToolsParser(tools=tools)
result = chain.invoke(query)
print(result)

# Output:
# [multiply(a=3, b=12), add(a=11, b=49)]

Complex Tool Integration (Different from the first version)

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

class SendEmail(BaseModel):
    """Send an email to specified recipients."""

    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):
    """Get weather information for a specific location."""

    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):
    """Search the web for given query."""

    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):
    """Create a calendar event."""

    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")

class TranslateText(BaseModel):
    """Translate text between languages."""

    text: str = Field(..., description="Text to translate")
    source_lang: str = Field(..., description="Source language code (e.g., 'en', 'es')")
    target_lang: str = Field(..., description="Target language code (e.g., 'fr', 'de')")

class SetReminder(BaseModel):
    """Set a reminder for a specific time."""

    message: str = Field(..., description="Reminder message")
    time: str = Field(..., description="Reminder time (ISO format)")
    priority: str = Field("normal", description="Priority level (low/normal/high)")
tools = [
    SendEmail,
    WeatherInfo,
    SearchWeb,
    CreateCalendarEvent,
    TranslateText,
    SetReminder
]
llm_tools = llm.bind_tools(tools)

# # Execute query and parser result (Different from the first version)
from langchain_core.output_parsers.openai_tools import PydanticToolsParser

query = "Set a reminder to call John at 3 PM tomorrow. Also, translate 'Hello, how are you?' to Spanish."
chain = llm_tools | PydanticToolsParser(tools=tools)
result = chain.invoke(query)
print(result)

# Output:
# [SetReminder(message='Set a reminder for a specific time.', time='3 PM tomorrow', priority='normal'),
# TranslateText(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 nguyenthanhthuan/function-calling-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

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