Function calling is a powerful new feature of large language models (LLMs) that allows them to interact with the real world in new and exciting ways. By calling external functions, LLMs can access data from databases, perform complex calculations, and interact with other systems. This opens up a wide range of new possibilities for LLMs, including:
- Building more intelligent and versatile chatbots: Chatbots that can call functions can access information and perform tasks that would be impossible for traditional chatbots. For example, a chatbot could use function calling to book a flight, order food, or check the weather.
- Creating new types of creative content: LLMs can use function calling to generate creative content that is more informative, engaging, and interactive. For example, an LLM could generate a poem that is tailored to the user’s interests, or a story that is based on the user’s input.
- Developing new AI applications: Function calling makes LLMs more powerful and versatile tools for developing new AI applications. For example, an LLM could be used to develop a new type of medical diagnostic system or a new type of financial trading algorithm.
Orion-14B-Chat-Plugin
The Orion-14B-Chat-Plugin is a specialized chat model designed for plugin and function call tasks. This model is part of the Orion-14B series, which is a multi-language large model with 140 billion parameters. It has demonstrated excellent performance in a series of tasks in a multi-language environment.
In the context of function calling, the Orion-14B-Chat-Plugin stands out due to its specialized design and impressive performance. It’s an excellent choice for those looking to leverage the power of large language models for plugin and function call tasks.
NexusRaven V2
NexusRaven V2 is a powerful large language model that excels in function calling tasks. Here’s a simplified overview of its key features:
- Superior Performance: It performs better than GPT-4 in complex function calling, especially with nested and composite functions, without needing specific training on these functions.
- Efficient Function Calling: NexusRaven V2 doesn’t depend on slow search or trial-and-error methods, making it faster and more reliable for function calling tasks.
- Cost-Effective and Fast: It is cheaper and quicker than GPT-4, making it a good choice for applications where speed and cost are important.
- Adapts to New Tools: The model can work with tools it hasn’t seen during training, showing great adaptability and outperforming similar-sized models.
- Excellent in Cybersecurity: It has a high success rate (95%) in using cybersecurity tools, much better than GPT-4’s performance in the same area.
Overall, NexusRaven V2 stands out for its advanced function calling abilities, cost-effectiveness, speed, adaptability, and strong performance in cybersecurity applications.
Nexusraven 13B
NexusRaven 13B is a powerful Large Language Model (LLM) designed for efficient function calling. It offers remarkable capabilities that outshine its peers, making it an excellent choice for both open-source and commercial applications.
| Feature | Description |
|---|---|
| Model Name | NexusRaven 13B |
| Type | Large Language Model (LLM) |
| Open-Source | Yes |
| Function Calling Support | Outstanding |
| Parameter Size | 13 billion parameters |
| Performance | 95% success rate in cybersecurity tasks |
| Inference Speed | Faster than GPT-4 |
| Generalization | Zero-shot capability comparable to GPT-3.5 |
| Commercial Permissiveness | Data not reliant on proprietary LLMs |
Key Advantages
1. Outstanding Performance
- NexusRaven 13B consistently achieves a 95% success rate in using cybersecurity tools like CVE/CPE Search and VirusTotal.
- Compare this to GPT-4, which only manages a 64% success rate.
- This translates to significant cost savings and faster processing times.
2. Versatility
- NexusRaven 13B can adapt to tools it has never seen before during training.
- It performs exceptionally well in zero-shot scenarios, matching GPT-3.5’s success rates.
- It outperforms other similar-sized open-source LLMs in this aspect.
3. Commercial Freedom
- NexusRaven-13B’s training doesn’t rely on data from proprietary LLMs like GPT-4.
- This means you have full control when using it in commercial applications.
- Enjoy the flexibility and security that comes with this independence.
Function Calling Mistral 7B
Function Calling Mistral 7B enhances the HuggingFace Instruct model by introducing function calling abilities. It can interpret user requests, responding with structured JSON that outlines the function and its necessary arguments. Its cross entropy training loss of 0.5 demonstrates reliable performance, albeit not as high as larger models.
When using Mistral 7B, users receive prompts to add any missing information, ensuring that the model’s responses are accurate and complete. Clear function descriptions and required or default argument values are provided, making it user-friendly and efficient.
| Feature | Description |
|---|---|
| Function Calling | Ability to understand and respond with JSON structures for function calls. |
| Relative Performance | Training losses of 0.5 indicate a moderate performance level compared to larger models. |
| Error Handling | Can prompt the user for missing information, ensuring accuracy in function execution. |
| User Interaction | Designed to check for all necessary input from users to complete the function call process. |
| Argument Clarity | Provides clear function descriptions and default values to guide user interaction. |
Yi-34B-200K-Llamafied-function-calling-v2
The Yi-34B-200K-Llamafied-function-calling-v2 is a cutting-edge large language model with 34 billion parameters and a 200k context, specifically designed for advanced function calling.
In its latest version (v2), the model introduces improvements for a more user-friendly experience. Notably, it now requires only brief function descriptions for inference, eliminating the need for extra instructions. Additionally, function descriptions are separated from the system prompt, ensuring that the model’s behavior in function calling remains independent of prompt biases.
In summary, the Yi-34B-200K-Llamafied-function-calling-v2 combines a powerful parameter count with simplified syntax and thoughtful design, offering users enhanced capabilities for natural language interactions with external functions.
| Feature | Description |
|---|---|
| Parameters | 34 billion |
| Context Size | 200k |
| Syntax Improvement | Shortened syntax: Only function descriptions required for inference |
| Prompt Independence | Function descriptions moved outside the system prompt, reducing bias or prompt-dependent behavior |
| Version | v2 |
| Purpose | Advanced function calling capabilities in large language models |
Function Calling Deepseek Coder Instruct
Function Calling Deepseek Coder Instruct is a transformative language model that is available in three distinct sizes to cater to a range of computational and performance needs: 1.3 billion, 6.7 billion, and 33 billion parameters.
These variants, known as Deepseek Coder 1.3B, 6.7B, and 33B, are each adept at extending natural language understanding with the capability to interpret and respond to function calling tasks. The model’s unique selling point is its ability to generate structured JSON responses that include the function name and the associated arguments, making it an excellent tool for developers who want to integrate natural language processing with code execution systems.
| Feature | Description |
|---|---|
| Model Sizes | Available in 1.3B, 6.7B, and 33B parameter models to suit various application scales and performance requirements. |
| Function Calling | Can interpret and execute function calls within the context of code, enhancing automation and efficiency in coding tasks. |
| JSON Structured Response | Generates responses in JSON format, detailing the function names and arguments for clear and structured outputs. |
| Natural Language Understanding | Combines the nuanced understanding of natural language with the technical execution of coding instructions. |
| Scalability | Designed to scale with application needs, providing options for different levels of complexity and processing power. |
| Versatility | Suitable for a wide range of coding environments and programming languages due to its function calling capabilities. |
Gorilla
Gorilla is a cutting-edge technology that empowers Large Language Models (LLMs) to interact with external tools through API invocations. In simple terms, it allows LLMs to perform specific tasks by communicating with various application programming interfaces (APIs). Gorilla is at the forefront of showcasing how LLMs can effectively utilize over 1,600 APIs and counting, all while minimizing the risk of generating inaccurate or irrelevant information.
| Feature | Description |
|---|---|
| API Invocation | Gorilla enables precise API invocation based on natural language queries, bridging the gap between language and code. |
| Reduced Hallucination | Gorilla enhances the accuracy of LLM-generated API calls, minimizing the risk of generating inaccurate information. |
| APIBench | A comprehensive collection of APIs, curated for ease of integration and training, simplifying LLM API interactions. |
| Parameter Size | 7, 13 |
| Integration Ease | Gorilla offers straightforward integration with LLMs, making it accessible for developers and researchers. |
| Community Engagement | Users can connect on Discord, contribute via pull requests, and share APIs, actively participating in Gorilla’s growth. |
Key Features:
- Precise API Invocation: Gorilla excels in determining the most suitable API to call based on a natural language query. It bridges the gap between human-friendly language and machine-readable instructions, ensuring that LLMs accurately request the desired actions.
- Reduced Hallucination: One of the primary challenges in working with LLMs is their tendency to produce information that isn’t entirely accurate or relevant. Gorilla addresses this issue by enhancing the precision of LLM-generated API calls, reducing the chances of hallucination or misinformation.
- APIBench: Gorilla includes a valuable resource known as APIBench, which comprises an extensive collection of APIs. These APIs are not only diverse but have also been carefully curated for ease of integration and training. This resource simplifies the process of training LLMs to work with various APIs effectively.
Glaive-function-calling-v1
Glaive-function-calling-v1 is a powerful open-source chat model with 2.7 billion parameters. It has been trained using data generated from Glaive’s synthetic data generation platform, offering function-calling capabilities akin to both gpt-3.5 and gpt-4.
| Specification | Details |
|---|---|
| Model Name | Glaive-function-calling-v1 |
| Parameters | 2.7 billion |
| Data Source | Glaive’s synthetic data generation platform |
| Function Calling Capability | Comparable to gpt-3.5 and gpt-4 |
| Conversation Support | Multi-turn conversations |
| Function Execution | Intelligent function execution based on conversation |
| Foundation | Built on Replit’s Code Model (replit/replit-code-v1-3b) |
Key Features:
1. Multi-Turn Conversations: This model excels in handling multi-turn conversations, making it ideal for more dynamic and interactive interactions with users.
2. Intelligent Function Execution: Glaive-function-calling-v1 possesses the ability to intelligently decide when to execute a function. This is achieved through a system prompt provided at the beginning of the conversation. It evaluates the ongoing conversation to determine the appropriate moments for function execution, enhancing its contextual understanding.
3. Built on Replit’s Code Model: This model is built on top of the Replit Code Model, specifically the https://huggingface.co/replit/replit-code-v1-3b model. This foundation ensures its proficiency in coding and programming tasks, making it a valuable resource for developers and programmers.
Function Calling Llama 2 (version 2)
| Specification | Description |
|---|---|
| Model Name | Function Calling Llama 2 (Version 2) |
| Model Type | Large Language Model (LLM) with Function Calling Capabilities |
| Integration Method | Prompt Engineering and API Integration |
| Function Description Syntax | Simplified; No detailed instructions required |
| Function Response Format | Structured JSON with Function Name and Arguments |
| Enhancements in Version 2 | – Shortened Syntax for Function Descriptions |
Function Calling Llama 2 is an advanced iteration of the Hugging Face Llama 2 models, specifically designed to empower Large Language Models (LLMs) with robust function calling capabilities. This innovative model introduces significant improvements over its predecessor, making it a powerful tool for various tasks involving function calls within LLMs.
Key Features of Function Calling Llama 2 (Version 2)
Improved Syntax: One of the standout features of Function Calling Llama 2 is its streamlined and simplified syntax. Unlike previous versions, where detailed instructions were essential for accurate function execution, Version 2 requires only concise function descriptions, making it remarkably user-friendly.
External Function Descriptions: In a noteworthy enhancement, the function descriptions have been separated from the system prompt. This pivotal change eliminates any interference from the system prompt’s training data on the behavior of function calling. It ensures that the model’s responses are solely driven by the provided function descriptions, enhancing its reliability and consistency.
