gorilla-openfunctions-v1
Maintainer: gorilla-llm
91
🔮
| 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
The gorilla-openfunctions-v1 model, developed by the team at Gorilla LLM, extends the Large Language Model (LLM) Chat Completion feature to formulate executable API calls based on natural language instructions and API context. This model builds on previous versions, including gorilla-openfunctions-v0, which could generate properly formatted JSON with the right arguments given a function and user intent.
The gorilla-openfunctions-v1 model adds the capability to handle parallel functions, allowing the model to choose between multiple functions. This makes the model more flexible and powerful for real-world applications that require structured data generation and decision-making.
Similar models include the gorilla-openfunctions-v2 from the same team, which further extends the functionality with support for multiple and parallel functions, as well as relevance detection and support for various programming languages. Another related model is the Llama-2-7b-chat-hf-function-calling-v2 from Trelis, which adds function calling capabilities to the Llama 2 language model.
Model inputs and outputs
Inputs
- Natural language instructions: The model takes natural language prompts from users describing the desired functionality, such as "Call me an Uber ride type 'Plus' in Berkeley at zipcode 94704 in 10 minutes".
- API context: The model also accepts a list of API function descriptions, including the function name, description, and parameter details.
Outputs
- Formatted API call: The model's output is a formatted API call, such as
uber.ride(loc="berkeley", type="plus", time=10), with the function name, arguments, and values correctly specified. - JSON response: The model can also return the API call in a structured JSON format, which is compatible with the OpenAI Functions API specification.
Capabilities
The gorilla-openfunctions-v1 model demonstrates the ability to translate natural language instructions into executable API calls. By understanding the user's intent and the available API functions, the model can generate the appropriate function call with the correct parameters. This capability is particularly valuable for building conversational AI assistants, no-code/low-code platforms, and other applications that require bridging the gap between natural language and structured data.
What can I use it for?
The gorilla-openfunctions-v1 model can be used in a variety of applications that require generating structured data based on natural language input. Some potential use cases include:
- Conversational AI assistants: The model can be integrated into chatbots and virtual assistants to allow users to request actions or information using natural language, which the model then translates into API calls.
- No-code/low-code platforms: The model can be used to power the natural language interfaces of no-code or low-code development platforms, enabling users to create custom applications without writing code.
- Workflow automation: The model can be used to automate business processes by translating natural language requests into the appropriate API calls to trigger specific actions or retrieve information.
Things to try
One interesting aspect of the gorilla-openfunctions-v1 model is its ability to handle parallel functions. This means the model can choose between multiple functions to execute based on the user's natural language input. This can be particularly useful for building intelligent routing systems, where the model selects the most appropriate API call or service to invoke based on the user's request.
Another interesting experiment would be to explore the model's versatility by providing it with API function descriptions in different programming languages, such as Python, Java, and JavaScript. This could demonstrate the model's ability to generate API calls in a variety of technical contexts, broadening its potential applications.
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
🌿
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
📉
gorilla-7b-hf-delta-v0
51
The gorilla-7b-hf-delta-v0 is an open-source API caller model developed by the Gorilla LLM team at UC Berkeley. It is a fine-tuned version of the LLaMA model that can reliably use Hugging Face APIs. The model is able to generate semantically- and syntactically-correct API calls given natural language instructions. This sets it apart from similar models like gorilla-openfunctions-v1 and gorilla-openfunctions-v2 which also focus on invoking APIs from language instructions. Model inputs and outputs Inputs Natural language prompts**: The model accepts natural language instructions as input to generate the appropriate API calls. Outputs API calls**: The model outputs a string representing the API call with the correct function name and arguments based on the input prompt. Capabilities The gorilla-7b-hf-delta-v0 model can reliably generate API calls in response to natural language instructions. For example, given the prompt "I want to generate an image from text," the model would output a semantically correct API call like dalle.generate(prompt="An illustration of a happy dog"). What can I use it for? The gorilla-7b-hf-delta-v0 model can be used to build applications that allow users to interact with APIs using natural language. This could include chatbots, virtual assistants, or low-code/no-code tools that generate API calls based on user input. The model's ability to accurately translate natural language into executable API calls makes it a valuable tool for developers who want to abstract away the complexity of API integration. Things to try One interesting aspect of the gorilla-7b-hf-delta-v0 model is its ability to handle a wide range of API types, from image generation to web scraping and beyond. Developers could experiment with prompting the model to generate calls for different types of APIs and see how it performs. Additionally, the model could be fine-tuned on domain-specific datasets to improve its performance on particular types of APIs or use cases.
Updated Invalid Date
↗️
glaive-function-calling-v1
64
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 {...} 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.
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