gorilla

Gorilla: Large Language Model Connected with Massive APIs

Latest Updates

📢 Check out our detailed Berkeley Function Calling Leaderboard changelog (Last updated: ) for the latest dataset / model updates to the Berkeley Function Calling Leaderboard!

• 🤖 [07/17/2025] Announcing BFCL V4 Agentic! As function-calling forms the bedrock of Agentic systems, BFCL V4 Agentic benchmark focuses on tool-calling in real-world agentic settings, featuring web search with multi-hop reasoning and error recovery, agent memory management, and format sensitivity evaluation. [Web-search Blog] [Memory Blog] [Format Sensitivity Blog] [PR] [Tweet]

• 🎯 [10/04/2024] Introducing the Agent Arena by Gorilla X LMSYS Chatbot Arena! Compare different agents in tasks like search, finance, RAG, and beyond. Explore which models and tools work best for specific tasks through our novel ranking system and community-driven prompt hub. [Blog] [Arena] [Leaderboard] [Dataset] [Tweet]

• 📣 [09/21/2024] Announcing BFCL V3 - Evaluating multi-turn and multi-step function calling capabilities! New state-based evaluation system tests models on handling complex workflows, sequential functions, and service states. [Blog] [Leaderboard] [Code] [Tweet]

• 🚀 [08/20/2024] Released BFCL V2 • Live! The Berkeley Function-Calling Leaderboard now features enterprise-contributed data and real-world scenarios. [Blog] [Live Leaderboard] [V2 Categories Leaderboard] [Tweet]

• ⚡️ [04/12/2024] Excited to release GoEx - a runtime for LLM-generated actions like code, API calls, and more. Featuring “post-facto validation” for assessing LLM actions after execution, “undo” and “damage confinement” abstractions to manage unintended actions & risks. This paves the way for fully autonomous LLM agents, enhancing interaction between apps & services with human-out-of-loop. [Blog] [Code] [Paper] [Tweet]

• ⏰ [04/01/2024] Introducing cost and latency metrics into Berkeley function calling leaderboard!

• :rocket: [03/15/2024] RAFT: Adapting Language Model to Domain Specific RAG is live! [MSFT-Meta blog] [Berkeley Blog]

• :trophy: [02/26/2024] Berkeley Function Calling Leaderboard is live!

• :dart: [02/25/2024] OpenFunctions v2 sets new SoTA for open-source LLMs!

• :fire: [11/16/2023] Excited to release Gorilla OpenFunctions

• 💻 [06/29/2023] Released gorilla-cli, LLMs for your CLI!

• 🟢 [06/06/2023] Released Commercially usable, Apache 2.0 licensed Gorilla models

• :rocket: [05/30/2023] Provided the CLI interface to chat with Gorilla!

• :rocket: [05/28/2023] Released Torch Hub and TensorFlow Hub Models!

• :rocket: [05/27/2023] Released the first Gorilla model! or :hugs:!

• :fire: [05/27/2023] We released the APIZoo contribution guide for community API contributions!

• :fire: [05/25/2023] We release the APIBench dataset and the evaluation code of Gorilla!

About

Gorilla enables LLMs to use tools by invoking APIs. Given a natural language query, Gorilla comes up with the semantically- and syntactically- correct API to invoke.

With Gorilla, we are the first to demonstrate how to use LLMs to invoke 1,600+ (and growing) API calls accurately while reducing hallucination. This repository contains inference code for running Gorilla finetuned models, evaluation code for reproducing results from our paper, and APIBench - the largest collection of APIs, curated and easy to be trained on!

Since our initial release, we’ve served ~500k requests and witnessed incredible adoption by developers worldwide. The project has expanded to include tools, evaluations, leaderboard, end-to-end finetuning recipes, infrastructure components, and the Gorilla API Store:

Project	Type	Description (click to expand)
Gorilla Paper	🤖 Model 📝 Fine-tuning 📚 Dataset 📊 Evaluation 🔧 Infra	Large Language Model Connected with Massive APIs • Novel finetuning approach for API invocation • Evaluation on 1,600+ APIs (APIBench) • Retrieval-augmented training for test-time adaptation
Gorilla OpenFunctions-V2	🤖 Model	Drop-in alternative for function calling, supporting multiple complex data types and parallel execution • Multiple & parallel function execution with OpenAI-compatible endpoints • Native support for Python, Java, JavaScript, and REST APIs with expanded data types • Function relevance detection to reduce hallucinations • Enhanced RESTful API formatting capabilities • State-of-the-art performance among open-source models
Berkeley Function Calling Leaderboard (BFCL)	📊 Evaluation 🏆 Leaderboard 🔧 Function Calling Infra 📚 Dataset	Comprehensive evaluation of function-calling capabilities • V1: Expert-curated dataset for evaluating single-turn function calling • V2: Enterprise-contributed data for real-world scenarios • V3: Multi-turn & multi-step function calling evaluation • Cost and latency metrics for all models • Interactive API explorer for testing • Community-driven benchmarking platform
Agent Arena	📊 Evaluation 🏆 Leaderboard	Compare LLM agents across models, tools, and frameworks • Head-to-head agent comparisons with ELO rating system • Framework compatibility testing (LangChain, AutoGPT) • Community-driven evaluation platform • Real-world task performance metrics
Gorilla Execution Engine (GoEx)	🔧 Infra	Runtime for executing LLM-generated actions with safety guarantees • Post-facto validation for verifying LLM actions after execution • Undo capabilities and damage confinement for risk mitigation • OAuth2 and API key authentication for multiple services • Support for RESTful APIs, databases, and filesystem operations • Docker-based sandboxed execution environment
Retrieval-Augmented Fine-tuning (RAFT)	📝 Fine-tuning 🤖 Model	Fine-tuning LLMs for robust domain-specific retrieval • Novel fine-tuning recipe for domain-specific RAG • Chain-of-thought answers with direct document quotes • Training with oracle and distractor documents • Improved performance on PubMed, HotpotQA, and Gorilla benchmarks • Efficient adaptation of smaller models for domain QA
Gorilla CLI	🤖 Model 🔧 Local CLI Infra	LLMs for your command-line interface • User-friendly CLI tool supporting ~1500 APIs (Kubernetes, AWS, GCP, etc.) • Natural language command generation with multi-LLM fusion • Privacy-focused with explicit execution approval • Command history and interactive selection interface
Gorilla API Zoo	📚 Dataset	A community-maintained repository of up-to-date API documentation • Centralized, searchable index of APIs across domains • Structured documentation format with arguments, versioning, and examples • Community-driven updates to keep pace with API changes • Rich data source for model training and fine-tuning • Enables retrieval-augmented training and inference • Reduces hallucination through up-to-date documentation

Getting Started

Quick Start

Try Gorilla in your browser:

• 🚀 Gorilla Colab Demo: Try the base Gorilla model
• 🌐 Gorilla Gradio Demo: Interactive web interface
• 🔥 OpenFunctions Colab Demo: Try the latest OpenFunctions model
• 🎯 OpenFunctions Website Demo: Experiment with function calling
• 📊 Berkeley Function Calling Leaderboard: Compare function calling capabilities

Installation Options

1. Gorilla CLI - Fastest way to get started

pip install gorilla-cli
gorilla generate 100 random characters into a file called test.txt

Learn more about Gorilla CLI →

2. Run Gorilla Locally

git clone https://github.com/ShishirPatil/gorilla.git
cd gorilla/inference

Detailed local setup instructions →

3. Use OpenFunctions

import openai

openai.api_key = "EMPTY"
openai.api_base = "http://luigi.millennium.berkeley.edu:8000/v1"

# Define your functions
functions = [{
    "name": "get_current_weather",
    "description": "Get weather in a location",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {"type": "string"},
            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["location"]
    }
}]

# Make API call
completion = openai.ChatCompletion.create(
    model="gorilla-openfunctions-v2",
    messages=[{"role": "user", "content": "What's the weather in San Francisco?"}],
    functions=functions
)

OpenFunctions documentation →

🔧 Other Quick Starts

• 📊 Evaluation & Benchmarking

  • Berkeley Function Calling Leaderboard: Compare function calling capabilities
  • Agent Arena: Evaluate agent workflows
  • Gorilla Paper Evaluation Scripts: Run your own evaluations

• 🛠️ Development Tools

  • GoEx: Safe execution of LLM-generated actions
  • RAFT: Fine-tune models for domain-specific tasks
  • API Store: Contribute and use APIs

Frequently Asked Questions

1. I would like to use Gorilla commercially. Is there going to be an Apache 2.0 licensed version?

Yes! We now have models that you can use commercially without any obligations.

2. Can we use Gorilla with other tools like Langchain etc?

Absolutely! You’ve highlighted a great aspect of our tools. Gorilla is an end-to-end model, specifically tailored to serve correct API calls (tools) without requiring any additional coding. It’s designed to work as part of a wider ecosystem and can be flexibly integrated within agentic frameworks and other tools.

Langchain, is a versatile developer tool. Its “agents” can efficiently swap in any LLM, Gorilla included, making it a highly adaptable solution for various needs.

The beauty of these tools truly shines when they collaborate, complementing each other’s strengths and capabilities to create an even more powerful and comprehensive solution. This is where your contribution can make a difference. We enthusiastically welcome any inputs to further refine and enhance these tools.

Check out our blog on How to Use Gorilla: A Step-by-Step Walkthrough to see all the different ways you can integrate Gorilla in your projects.

Project Roadmap

In the immediate future, we plan to release the following:

• Multimodal function-calling leaderboard
• Agentic function-calling leaderboard
• New batch of user contributed live function calling evals.
• BFCL metrics to evaluate contamination
• Openfunctions-v3 model to support more languages and multi-turn capability
• Agent Arena to compare LLM agents across models, tools, and frameworks [10/04/2024]
• Multi-turn and multi-step function calling evaluation [09/21/2024]
• User contributed Live Function Calling Leaderboard [08/20/2024]
• BFCL systems metrics including cost and latency [04/01/2024]
• Gorilla Execution Engine (GoEx) - Runtime for executing LLM-generated actions with safety guarantees [04/12/2024]
• Berkeley Function Calling leaderboard (BFCL) for evaluating tool-calling/function-calling models [02/26/2024]
• Openfunctions-v2 with more languages (Java, JS, Python), relevance detection [02/26/2024]
• API Zoo Index for easy access to all APIs [02/16/2024]
• Openfunctions-v1, Apache 2.0, with parallel and multiple function calling [11/16/2023]
• Openfunctions-v0, Apache 2.0 function calling model [11/16/2023]
• Release a commercially usable, Apache 2.0 licensed Gorilla model [06/05/2023]
• Release weights for all APIs from APIBench [05/28/2023]
• Run Gorilla LLM locally [05/28/2023]
• Release weights for HF model APIs [05/27/2023]
• Hosted Gorilla LLM chat for HF model APIs [05/27/2023]
• Opening up the APIZoo for contributions from community
• Dataset and Eval Code

License

Gorilla is Apache 2.0 licensed, making it suitable for both academic and commercial use.

Contact

• 💬 Join our Discord Community
• 🐦 Follow us on X

Citation

@article{patil2023gorilla,
  title={Gorilla: Large Language Model Connected with Massive APIs},
  author={Shishir G. Patil and Tianjun Zhang and Xin Wang and Joseph E. Gonzalez},
  year={2023},
  journal={arXiv preprint arXiv:2305.15334},
}