Harnessing the Power of LLM to Enrich API Description and URL Generation

Introduction

In the ever-evolving world of technology, Application Programming Interfaces (APIs) are the backbone of seamless communication between software applications. Developers heavily rely on API documentation to understand and utilize these interfaces effectively. However, searching for the correct API within vast documentation can be daunting. This blog demonstrates an alternative approach to using LLM to assist developers in effortlessly navigating through API documentation, extracting relevant information, and easily generating API URLs.

The Power of Prompt in LLM

In this blog, I am using Cohere, the advanced Language Model. Before we delve into Cohere’s capabilities, let’s discuss the concept of a “prompt” in a Language Model. In simple terms, a prompt is a set of instructions or initial text provided to the model to guide its generation process. For instance, when using Cohere, developers can input a prompt like “Generate a description for the Oracle HCM API to retrieve employee information.” This instruction directs the model’s focus and ensures the generated content aligns with the specific query.

The Struggle with API Documentation Search

Searching for an API can be a daunting challenge for developers in the ever-evolving world of technology. With Application Programming Interfaces (APIs) serving as the backbone of seamless communication between software applications, developers heavily rely on accurate and up-to-date API documentation. However, finding the correct API for a specific use case becomes a complex and time-consuming task within extensive API repositories. Developers may encounter obstacles like ambiguous or inconsistent naming conventions, incomplete or outdated documentation, a lack of relevant examples, difficulties in identifying the correct API parameters, and the need for manual searches through multiple documents. These struggles can impede productivity and innovation, making it essential to find efficient solutions to streamline the API documentation search process.

Oracle HCM (Human Capital Management) offers various APIs that cater to diverse use cases, from employee information retrieval to payroll management. Navigating the extensive API documentation to find the most appropriate API for a given use case is often complex and time-consuming. Such challenges can hinder productivity and innovation in software development.

Below is a systematic and efficient process that empowers developers to easily harness APIs. This process involves obtaining the swagger file from the API documentation URL, processing it with a Python module, and using a Language Model (LLM) to generate formatted API documentation with enriched descriptions. We then initialize embedding and store API doc vectors in a vector store, enabling efficient retrieval. Finally, we seamlessly generate API URLs using the formatted API documentation and generated descriptions.

Enrich API Description with and for LLM

Enter LLM, the game-changer that can revolutionize developers’ interaction with API documentation. Leveraging the power of advanced natural language processing, using LLM like Cohere can generate descriptive content for APIs based on contextual prompts.

For instance, if a developer seeks to retrieve employee information from Oracle HCM, they can simply provide the following prompt to Cohere:
“Generate a description for the API to retrieve employee information from Oracle HCM.”

Original Description:

Enriched Description:

Cohere will then process the prompt, analyze the underlying meaning, and generate a relevant description for the suitable API. This eliminates the need for developers to manually browse through lengthy documentation, streamlining the development process and boosting productivity.

Storing API in the Vector Database Using Embedding

Typical usage of the LLM use case goes beyond generating API descriptions; in some cases, we need to be able to store the data in a vector database using embedding for fast retrieval and performance. Embedding is a technique representing APIs document as numerical vectors in a multi-dimensional space. Each API’s document’s unique characteristics, functionalities, and relationships are mapped into these vectors in this use case.

By converting APIs documents into vectors and storing them in a database, developers can efficiently search, compare, and retrieve APIs based on their relevance to specific use cases. This enables quick and accurate identification of the most suitable APIs, reducing development time and minimizing the risk of errors. 

The following code snippet aims to generate embeddings for API documentation using Cohere’s embedding service. The process involves initializing the CohereEmbeddings object with the Cohere API key, enabling access to Cohere’s embedding capabilities. A persistent client for the ChromaDB is also used to store the embeddings. The API documentation is read from the file “hcm_api_doc.txt” and then split into smaller chunks using the RecursiveCharacterTextSplitter. The resulting text chunks are passed through Cohere’s embeddings model, generating numerical representations (embeddings) for each chunk. These embeddings are then stored in the ChromaDB using the persistent client, allowing for efficient retrieval and manipulation of the API documentation. The final result is the persistence of the embeddings in the “./chroma_db” directory for future usage and analysis.

from langchain.llms import Cohere
from langchain.embeddings import CohereEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
import chromadb
import cohere
from chromadb.config import Settings

embeddings = CohereEmbeddings(cohere_api_key=cohere_api_key)
chromadb_client = chromadb.PersistentClient(path="./chroma_db")
f = open("hcm_api_doc.txt", "r")
text = f.read()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=1, separators = ["API documentation"], length_function = len) 
docs = text_splitter.split_text(text) 
db = Chroma.from_texts(docs, embeddings, client=chromadb_client, client_settings=Settings(allow_reset=True), persist_directory="./chroma_db") 
db.persist()

With APIs document stored in the vector database, developers can effortlessly search for the most appropriate API to address their specific needs. Instead of grappling with the complexities of manual API search, they can utilize Cohere’s search capabilities to find the perfect match.

The following code snippet aims to retrieve relevant API documentation based on a specific query. The query “Which API can I use to get the enrollment data” is used to find the most suitable API for retrieving enrollment data. The code uses a retriever object, db_retriever, to access the stored API documentation previously embedded and stored in the ChromaDB. The get_relevant_documents method is then called on the db_retriever with the provided query, returning a list of relevant documents that match the query. Finally, the content of the first document in the list is printed, displaying the relevant API documentation that fulfills the requirement to retrieve enrollment data. This process streamlines the search for the appropriate API within the database and provides developers with the necessary information to proceed with their development tasks.

query = "Which API can I use to get the employee data without empsUniqID"
db_retriever = db.as_retriever()
docs = db_retriever.get_relevant_documents(query)
print(docs[0].page_content)

Provide a simple prompt like “Which API can I use to get the employee data without empsUniqID.”.  Using a large language model like Cohere, we can search the vector database and present the most relevant API to retrieve the employee information from Oracle HCM.  This streamlined process saves valuable time and effort, promoting a seamless development experience.

The output of the above prompt:

Generating API URLs using LLM

We can take LLM’s capabilities even further by assisting developers in generating API URLs through interactive question-based prompts.  By posing the queries below, developers can quickly obtain the correct API URL without navigating through documentation manually.  Incorporating LLM with few-shot learning is another exciting possibility for aiding developers in generating more accurate API URLs.  This powerful combination of language model capabilities and contextual understanding promises to significantly enhance the efficiency and productivity of developers working with APIs.

API url: https://example.com/hcmRestApi/resources/11.13.18.05/emps?q=FirstName=Casey;LastName=Brown&fields=HireDate

API url: https://example.com/hcmRestApi/resources/11.13.18.05/emps?q=FirstName=Casey;LastName=Brown&fields=HireDate&onlyData=True

You are given the below API Documentation:
{api_docs}
Using this documentation, generate the full API url to call for answering the user question.
You should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question.
Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
Do not include data not in the documentation.
Question:{question}
API url:

Cohere processes the question, using the API docs, and presents the URL in a structured and user-friendly format. This feature ensures accuracy and precision in API utilization while eliminating the need for trial and error.

co = cohere.Client(cohere_api_key)
for doc in docs:
  prompt = template.format(api_docs = doc.page_content, question= question)
  response = co.generate(
    prompt=prompt,
    model='command',
    max_tokens=1000,
    return_likelihoods="None",
    temperature=0,
    p = 1,
    truncate= "END"
  )
  generated = response
  print(generated[0].text)

With a question like: “I don’t have Casey Brown employee ID, but who is Casey Brown? When was he hired”

Output:

https://example.com/hcmRestApi/resources/11.13.18.05/emps?q=FirstName=Casey;LastName=Brown&fields=HireDate

Conclusion

Large language models have emerged as a powerful way to help developers significantly simplify the process of searching, understanding, and utilizing APIs from API documentation.  By harnessing the capabilities of prompts, API description generation, vector database embedding, and interactive question-based prompts, LLM empowers developers to be more productive, efficient, and innovative.

With the availability of the large language models at their disposal, developers can bid farewell to the struggles of API documentation search and focus on what truly matters – crafting exceptional software solutions that drive progress and transform the technological landscape.  As LLM, like Cohere, continues to evolve and improve, it promises to revolutionize how developers interact with API documentation, making the future of software development brighter and more accessible.