glaive-function-calling-v1
Maintainer: glaiveai
64
↗️
| Property | Value |
|---|---|
| Run this model | Run on HuggingFace |
| API spec | View on HuggingFace |
| Github link | No Github link provided |
| Paper link | No paper link provided |
Create account to get full access
Model overview
glaive-function-calling-v1 is a 2.7B parameter AI model trained by glaiveai that has similar function calling abilities as GPT-3.5 and GPT-4. It is built on top of the replit/replit-code-v1-3b model and can have multi-turn conversations, intelligently choosing when to execute a provided function based on the conversation.
Similar models include gorilla-openfunctions-v1 and gorilla-openfunctions-v2, which also provide function calling capabilities.
Model inputs and outputs
Inputs
- A provided function specification in JSON format at the start of the conversation
- User prompts that can reference the provided functions
Outputs
- Function calls in the format
<functioncall> {...} - Responses that incorporate the results of the executed functions
Capabilities
The glaive-function-calling-v1 model can intelligently decide when to execute a provided function based on the conversation context. It supports multi-turn interactions, allowing the user to build upon previous function calls.
What can I use it for?
The glaive-function-calling-v1 model could be useful for building conversational applications that allow users to interact with and execute specific functions, such as planning a vacation, booking a ride, or retrieving information. Its ability to have multi-turn dialogues and choose when to execute functions makes it well-suited for interactive, task-oriented applications.
Things to try
One interesting thing to try with glaive-function-calling-v1 would be to provide it with a diverse set of functions and see how it handles more complex, multi-step request flows. You could also experiment with different types of functions beyond the vacation planning example, to see how the model generalizes to other domains.
This summary was produced with help from an AI and may contain inaccuracies - check out the links to read the original source documents!
Related Models
↗️
glaive-coder-7b
53
The glaive-coder-7b is a 7 billion parameter code model developed by glaiveai that has been trained on a dataset of ~140k programming-related problems and solutions. This model is a fine-tuned version of the CodeLLama-7b model, giving it enhanced capabilities for code-related tasks. The glaive-coder-7b model is similar to other code-focused models like glaive-function-calling-v1 and CodeShell-7B, which also aim to provide powerful code generation and assistance capabilities. However, the glaive-coder-7b model has been specifically trained on a larger dataset of programming problems, potentially giving it an advantage for certain coding-related tasks. Model inputs and outputs Inputs Prompts**: The model accepts prompts in a specific format, where the instruction is wrapped in [INST] tags and the user message is provided afterwards. Outputs Code and text responses**: The model generates code and text responses based on the provided prompt, with the model's output wrapped in `` tags. Capabilities The glaive-coder-7b model is capable of both single-instruction following and multi-turn conversations related to coding tasks. It has been trained to serve as a code assistant, helping with a variety of programming-related activities such as code generation, debugging, and task completion. What can I use it for? The glaive-coder-7b model can be a valuable tool for developers and programmers, providing assistance with a wide range of coding-related tasks. Some potential use cases include: Generating code snippets and solutions for programming challenges Helping with code refactoring and optimization Assisting with debugging and troubleshooting Providing explanations and guidance for programming concepts The model's Code Models Arena initiative also aims to gather user feedback and preferences to help improve the performance and usefulness of code-focused AI models like the glaive-coder-7b. Things to try One interesting aspect of the glaive-coder-7b model is its ability to engage in multi-turn conversations, allowing users to iteratively refine and build upon their coding-related tasks. This could be particularly useful for complex programming problems that require a more interactive and collaborative approach. Additionally, the model's strong performance on benchmarks like HumanEval and MBPP suggests that it may be a valuable tool for tasks like algorithmic problem-solving and code generation. Developers could explore using the glaive-coder-7b model to generate initial code solutions and then refine them further. Overall, the glaive-coder-7b model appears to be a capable and versatile tool for programmers and developers, with the potential to streamline various coding-related workflows and tasks.
Updated Invalid Date
👁️
Llama-2-7b-chat-hf-function-calling
47
The Llama-2-7b-chat-hf-function-calling model extends the popular Hugging Face Llama 2 models with function calling capabilities. Developed by Trelis, this model responds with a structured JSON argument containing the function name and arguments, allowing for seamless integration into applications that require programmatic interactions. Model inputs and outputs Inputs Text**: The model takes text prompts as input, which can include instructions for the desired function to be executed. Outputs Structured JSON**: The model generates a JSON object with two key-value pairs - "function" (the name of the function) and "arguments" (the arguments for the function). Capabilities The Llama-2-7b-chat-hf-function-calling model is capable of understanding function call requests and generating the appropriate JSON response. This allows developers to easily incorporate the model's functionality into their applications, automating tasks and integrating with various systems. What can I use it for? With the function calling capabilities of this model, you can build applications that streamline workflows, automate repetitive tasks, and enhance user experiences. Some potential use cases include: Developing intelligent chatbots or virtual assistants that can execute specific functions on behalf of users Integrating the model into business software to enable natural language-driven automation Building productivity tools that allow users to issue commands and have the model handle the underlying logic Things to try One interesting aspect of this model is its ability to handle function calls with varying numbers of arguments, from 0 to 3. You can experiment with different function descriptions and prompts to see how the model responds, ensuring that the expected JSON format is generated correctly. Additionally, you can explore how the model's performance scales with larger parameter sizes, such as the 13B, 70B, and other versions available from the Trelis creator profile.
Updated Invalid Date
❗
Llama-2-7b-chat-hf-function-calling-v2
121
Llama-2-7b-chat-hf-function-calling-v2 is a large language model developed by Trelis that extends the capabilities of the Hugging Face Llama 2 model by adding function calling abilities. This model responds with a structured JSON output containing the function name and arguments. Similar models include the Llama 2 7B chat model and the Llama 2 13B chat model, which are fine-tuned for dialogue use cases. The maintainer Trelis has a profile at https://aimodels.fyi/creators/huggingFace/Trelis. Model inputs and outputs Inputs Text prompts Outputs Structured JSON output containing a function name and arguments Capabilities The Llama-2-7b-chat-hf-function-calling-v2 model can respond to prompts with a structured JSON output that includes a function name and the necessary arguments. This allows the model to be used for tasks that require programmatic outputs, such as API calls or code generation. What can I use it for? The Llama-2-7b-chat-hf-function-calling-v2 model can be useful for building applications that need to generate dynamic, structured outputs. For example, you could use it to build a virtual assistant that can perform API calls or generate code snippets on demand. The maintainer also offers other function calling models, such as the Yi-6B-200K-Llamafied-function-calling-v2 and Yi-34B-200K-Llamafied-chat-SFT-function-calling-v2, which may be worth exploring for your use case. Things to try One interesting aspect of the Llama-2-7b-chat-hf-function-calling-v2 model is its ability to generate structured outputs. You could try prompting the model with requests for specific API calls or code snippets and see how it responds. Additionally, you could experiment with providing the model with different types of prompts or instructions to see how it adapts its function call outputs.
Updated Invalid Date
🌿
gorilla-openfunctions-v2
154
The gorilla-openfunctions-v2 model from the Gorilla LLM team is an advanced open-source language model that extends the capabilities of large language models to enable executable API generation from natural language instructions. Compared to similar models like openchat-3.5-1210, the gorilla-openfunctions-v2 model supports a wider range of functionality, including the ability to choose between multiple functions, call the same function in parallel with different parameter values, and combine both multiple and parallel function calls in a single generation. The model also adds support for relevance detection, allowing it to determine when a chatbot query should result in a function call versus a regular chat response. Model inputs and outputs The gorilla-openfunctions-v2 model takes natural language instructions as input and generates executable API calls as output. This allows users to interact with the model using everyday language to request specific actions or data, rather than having to manually construct API requests. Inputs Natural language instructions**: The model accepts text prompts that describe the desired functionality, such as "Get the current weather for Seattle". Outputs Executable API calls**: The model generates API calls that can be directly executed, including the necessary function names, parameter values, and data types. For example, the output might be get_weather_data(coordinates=get_coordinates_from_city(city_name='Seattle')). Capabilities The gorilla-openfunctions-v2 model is capable of generating complex, nested API calls that combine multiple functions. It supports a variety of programming languages, including Python, Java, and JavaScript, and can handle a range of data types such as strings, numbers, booleans, lists, and dictionaries. The model's relevance detection feature also allows it to determine when a query should result in a function call versus a regular chat response. What can I use it for? The gorilla-openfunctions-v2 model can be used to build intelligent, natural language-driven applications that interact with APIs. For example, you could create a virtual assistant that allows users to request information or perform actions using plain language, without the need for specialized technical knowledge. The model's capabilities could be particularly useful in industries like e-commerce, finance, or scientific research, where users frequently need to access and manipulate data through APIs. Things to try One interesting aspect of the gorilla-openfunctions-v2 model is its ability to handle parallel function calls. This could be useful for scenarios where you need to perform the same operation multiple times with different input values, such as fetching weather data for a list of cities or running a simulation with various parameter settings. You could also experiment with the model's relevance detection feature, testing how it responds to different types of queries and ensuring that it can distinguish between requests for information and requests for executable actions.
Updated Invalid Date