Enhancing LLMs with Structured Outputs and Function Calling

Introduction

Suppose you are interacting with a friend who is knowledgeable but at times lacks concrete/informed responses or when he/she does not respond fluently when faced with complicated questions. What we are doing here is similar to the prospects that currently exist with Large Language Models. They are very helpful, although their quality and relevance of delivered structured answers may be satisfactory or niche.

In this article, we will explore how future technologies like function calling and Retrieval-Augmented Generation (RAG) can enhance LLMs. We’ll discuss their potential to create more reliable and meaningful conversational experiences. You will learn how these technologies work, their benefits, and the challenges they face. Our goal is to equip you with both knowledge and the skills to improve LLM performance in different scenarios.

This article is based on a recent talk given by Ayush Thakur on Enhancing LLMs with Structured Outputs and Function Calling, in the DataHack Summit 2024.

Learning Outcomes

• Understand the fundamental concepts and limitations of Large Language Models.
• Learn how structured outputs and function calling can enhance the performance of LLMs.
• Explore the principles and advantages of Retrieval-Augmented Generation (RAG) in improving LLMs.
• Identify key challenges and solutions in evaluating LLMs effectively.
• Compare function calling capabilities between OpenAI and Llama models.

What are LLMs?

Large Language Models (LLMs) are advanced ai systems designed to understand and generate natural language based on large datasets. Models like GPT-4 and LLaMA use deep learning algorithms to process and produce text. They are versatile, handling tasks like language translation and content creation. By analyzing vast amounts of data, LLMs learn language patterns and apply this knowledge to generate natural-sounding responses. They predict text and format it logically, enabling them to perform a wide range of tasks across different fields.

Limitations of LLMs

Let us now explore limitations of LLMs.

• Inconsistent Accuracy: Their results are sometimes inaccurate or are not as reliable as expected especially when dealing with intricate situations.
• Lack of True Comprehension: They may produce text which may sound reasonable but can be actually the wrong information or a Spin off because of their lack of insight.
• Training Data Constraints: The outputs they produce are restrained by their training data, which at times can be either bias or contain gaps.
• Static Knowledge Base: LLMs have a static knowledge base that does not update in real-time, making them less effective for tasks requiring current or dynamic information.

Importance of Structured Outputs for LLMs

We will now look into the importance of structured outputs of LLMs.

• Enhanced Consistency: Structured outputs provide a clear and organized format, improving the consistency and relevance of the information presented.
• Improved Usability: They make the information easier to interpret and utilize, especially in applications needing precise data presentation.
• Organized Data: Structured formats help in organizing information logically, which is beneficial for generating reports, summaries, or data-driven insights.
• Reduced Ambiguity: Implementing structured outputs helps reduce ambiguity and enhances the overall quality of the generated text.

Interacting with LLM: Prompting

Prompting Large Language Models (LLMs) involves crafting a prompt with several key components:

• Instructions: Clear directives on what the LLM should do.
• Context: Background information or prior tokens to inform the response.
• Input Data: The main content or query the LLM needs to process.
• Output Indicator: Specifies the desired format or type of response.

For example, to classify sentiment, you provide a text like “I think the food was okay” and ask the LLM to categorize it into neutral, negative, or positive sentiments.

In practice, there are various approaches to prompting:

• Input-Output: Directly inputs the data and receives the output.
• Chain of Thought (CoT): Encourages the LLM to reason through a sequence of steps to arrive at the output.
• Self-Consistency with CoT (CoT-SC): Uses multiple reasoning paths and aggregates results for improved accuracy through majority voting.

These methods help in refining the LLM’s responses and ensuring the outputs are more accurate and reliable.

How does LLM Application differ from Model Development?

Let us now look into the table below to understand how LLM application differ from model development.

Function Calling with LLMs

Function Calling with LLMs involves enabling large language models (LLMs) to execute predefined functions or code snippets as part of their response generation process. This capability allows LLMs to perform specific actions or computations beyond standard text generation. By integrating function calling, LLMs can interact with external systems, retrieve real-time data, or execute complex operations, thereby expanding their utility and effectiveness in various applications.

Benefits of Function Calling

• Enhanced Interactivity: Function calling enables LLMs to interact dynamically with external systems, facilitating real-time data retrieval and processing. This is particularly useful for applications requiring up-to-date information, such as live data queries or personalized responses based on current conditions.
• Increased Versatility: By executing functions, LLMs can handle a wider range of tasks, from performing calculations to accessing and manipulating databases. This versatility enhances the model’s ability to address diverse user needs and provide more comprehensive solutions.
• Improved Accuracy: Function calling allows LLMs to perform specific actions that can improve the accuracy of their outputs. For example, they can use external functions to validate or enrich the information they generate, leading to more precise and reliable responses.
• Streamlined Processes: Integrating function calling into LLMs can streamline complex processes by automating repetitive tasks and reducing the need for manual intervention. This automation can lead to more efficient workflows and faster response times.

Limitations of Function Calling with Current LLMs

• Limited Integration Capabilities: Current LLMs may face challenges in seamlessly integrating with diverse external systems or functions. This limitation can restrict their ability to interact with various data sources or perform complex operations effectively.
• Security and Privacy Concerns: Function calling can introduce security and privacy risks, especially when LLMs interact with sensitive or personal data. Ensuring robust safeguards and secure interactions is crucial to mitigate potential vulnerabilities.
• Execution Constraints: The execution of functions by LLMs may be constrained by factors such as resource limitations, processing time, or compatibility issues. These constraints can impact the performance and reliability of function calling features.
• Complexity in Management: Managing and maintaining function calling capabilities can add complexity to the deployment and operation of LLMs. This includes handling errors, ensuring compatibility with various functions, and managing updates or changes to the functions being called.

Function Calling Meets Pydantic

Pydantic objects simplify the process of defining and converting schemas for function calling, offering several benefits:

• Automatic Schema Conversion: Easily transform Pydantic objects into schemas ready for LLMs.
• Enhanced Code Quality: Pydantic handles type checking, validation, and control flow, ensuring clean and reliable code.
• Robust Error Handling: Built-in mechanisms for managing errors and exceptions.
• Framework Integration: Tools like Instructor, Marvin, Langchain, and LlamaIndex utilize Pydantic’s capabilities for structured output.

Function Calling: Fine-tuning

Enhancing function calling for niche tasks involves fine-tuning small LLMs to handle specific data curation needs. By leveraging techniques like special tokens and LoRA fine-tuning, you can optimize function execution and improve the model’s performance for specialized applications.

Data Curation: Focus on precise data management for effective function calls.

• Single-Turn Forced Calls: Implement straightforward, one-time function executions.
• Parallel Calls: Utilize concurrent function calls for efficiency.
• Nested Calls: Handle complex interactions with nested function executions.
• Multi-Turn Chat: Manage extended dialogues with sequential function calls.

Special Tokens: Use custom tokens to mark the beginning and end of function calls for better integration.

Model Training: Start with instruction-based models trained on high-quality data for foundational effectiveness.

LoRA Fine-Tuning: Employ LoRA fine-tuning to enhance model performance in a manageable and targeted manner.

This shows a request to plot stock prices of Nvidia (NVDA) and Apple (AAPL) over two weeks, followed by function calls fetching the stock data.

RAG (Retrieval-Augmented Generation) for LLMs

Retrieval-Augmented Generation (RAG) combines retrieval techniques with generation methods to improve the performance of Large Language Models (LLMs). RAG enhances the relevance and quality of outputs by integrating a retrieval system within the generative model. This approach ensures that the generated responses are more contextually rich and factually accurate. By incorporating external knowledge, RAG addresses some limitations of purely generative models, offering more reliable and informed outputs for tasks requiring accuracy and up-to-date information. It bridges the gap between generation and retrieval, improving overall model efficiency.

How RAG Works

Key components include:

• Document Loader: Responsible for loading documents and extracting both text and metadata for processing.
• Chunking Strategy: Defines how large text is split into smaller, manageable pieces (chunks) for embedding.
• Embedding Model: Converts these chunks into numerical vectors for efficient comparison and retrieval.
• Retriever: Searches for the most relevant chunks based on the query, determining how good or accurate they are for response generation.
• Node Parsers & Postprocessing: Handle filtering and thresholding, ensuring only high-quality chunks are passed forward.
• Response Synthesizer: Generates a coherent response from the retrieved chunks, often with multi-turn or sequential LLM calls.
• Evaluation: The system checks the accuracy, factuality, and reduces hallucination in the response, ensuring it reflects real data.

This image represents how RAG systems combine retrieval and generation to provide accurate, data-driven answers.

• Retrieval Component: The RAG framework begins with a retrieval process where relevant documents or data are fetched from a pre-defined knowledge base or search engine. This step involves querying the database using the input query or context to identify the most pertinent information.
• Contextual Integration: Once relevant documents are retrieved, they are used to provide context for the generative model. The retrieved information is integrated into the input prompt, helping the LLM generate responses that are informed by real-world data and relevant content.
• Generation Component: The generative model processes the enriched input, incorporating the retrieved information to produce a response. This response benefits from the additional context, leading to more accurate and contextually appropriate outputs.
• Refinement: In some implementations, the generated output may be refined through further processing or re-evaluation. This step ensures that the final response aligns with the retrieved information and meets quality standards.

Benefits of Using RAG with LLMs

• Improved Accuracy: By incorporating external knowledge, RAG enhances the factual accuracy of the generated outputs. The retrieval component helps provide up-to-date and relevant information, reducing the risk of generating incorrect or outdated responses.
• Enhanced Contextual Relevance: RAG allows LLMs to produce responses that are more contextually relevant by leveraging specific information retrieved from external sources. This results in outputs that are better aligned with the user’s query or context.
• Increased Knowledge Coverage: With RAG, LLMs can access a broader range of knowledge beyond their training data. This expanded coverage helps address queries about niche or specialized topics that may not be well-represented in the model’s pre-trained knowledge.
• Better Handling of Long-Tail Queries: RAG is particularly effective for handling long-tail queries or uncommon topics. By retrieving relevant documents, LLMs can generate informative responses even for less common or highly specific queries.
• Enhanced User Experience: The integration of retrieval and generation provides a more robust and useful response, improving the overall user experience. Users receive answers that are not only coherent but also grounded in relevant and up-to-date information.

Evaluation of LLMs

Evaluating large language models (LLMs) is a crucial aspect of ensuring their effectiveness, reliability, and applicability across various tasks. Proper evaluation helps identify strengths and weaknesses, guides improvements, and ensures that LLMs meet the required standards for different applications.

Importance of Evaluation in LLM Applications

• Ensures Accuracy and Reliability: Performance assessment aids in understanding how well and consistently an LLM completes tasks like text generation, summarization, or question answering. And while I’m in favor of pushing for a more holistic approach in the classroom, feedback that is particular in this manner is highly valuable for a very specific type of application greatly reliance on detail, in fields like medicine or law.
• Guides Model Improvements: Through evaluation, developers can identify specific areas where an LLM may fall short. This feedback is crucial for refining model performance, adjusting training data, or modifying algorithms to enhance overall effectiveness.
• Measures Performance Against Benchmarks: Evaluating LLMs against established benchmarks allows for comparison with other models and previous versions. This benchmarking process helps us understand the model’s performance and identify areas for improvement.
• Ensures Ethical and Safe Use: It has a part in determining the extent to which LLMs respects ethical principles and the standards concerning safety. It assists in identifying bias, unwanted content and any other factor that may cause the responsible use of the technology to be compromised.
• Supports Real-World Applications: It is for this reason that a proper and thorough assessment is required in order to understand how LLMs work in practice. This involves evaluating their performance in solving various tasks, operating across different scenarios, and producing valuable results in real-world cases.

Challenges in Evaluating LLMs

• Subjectivity in Evaluation Metrics: Many evaluation metrics, such as human judgment of relevance or coherence, can be subjective. This subjectivity makes it challenging to assess model performance consistently and may lead to variability in results.
• Difficulty in Measuring Nuanced Understanding: Evaluating an LLM’s ability to understand complex or nuanced queries is inherently difficult. Current metrics may not fully capture the depth of comprehension required for high-quality outputs, leading to incomplete assessments.
• Scalability Issues: Evaluating LLMs becomes increasingly expensive as these structures expand and become more intricate. It is also important to note that, comprehensive evaluation is time consuming and needs a lot of computational power that can in a way hinder the testing process.
• Bias and Fairness Concerns: It is not easy to assess LLMs for bias and fairness since bias can take different shapes and forms. To ensure accuracy remains consistent across different demographics and situations, rigorous and elaborate assessment methods are essential.
• Dynamic Nature of Language: Language is constantly evolving, and what constitutes accurate or relevant information can change over time. Evaluators must assess LLMs not only for their current performance but also for their adaptability to evolving language trends, given the models’ dynamic nature.

Constrained Generation of Outputs for LLMs

Constrained generation involves directing an LLM to produce outputs that adhere to specific constraints or rules. This approach is essential when precision and adherence to a particular format are required. For example, in applications like legal documentation or formal reports, it’s crucial that the generated text follows strict guidelines and structures.

You can achieve constrained generation by predefining output templates, setting content boundaries, or using prompt engineering to guide the LLM’s responses. By applying these constraints, developers can ensure that the LLM’s outputs are not only relevant but also conform to the required standards, reducing the likelihood of irrelevant or off-topic responses.

Lowering Temperature for More Structured Outputs

The temperature parameter in LLMs controls the level of randomness in the generated text. Lowering the temperature results in more predictable and structured outputs. When the temperature is set to a lower value (e.g., 0.1 to 0.3), the model’s response generation becomes more deterministic, favoring higher-probability words and phrases. This leads to outputs that are more coherent and aligned with the expected format.

For applications where consistency and precision are crucial, such as data summaries or technical documentation, lowering the temperature ensures that the responses are less varied and more structured. Conversely, a higher temperature introduces more variability and creativity, which might be less desirable in contexts requiring strict adherence to format and clarity.

Chain of Thought Reasoning for LLMs

Chain of thought reasoning is a technique that encourages LLMs to generate outputs by following a logical sequence of steps, similar to human reasoning processes. This method involves breaking down complex problems into smaller, manageable components and articulating the thought process behind each step.

By employing chain of thought reasoning, LLMs can produce more comprehensive and well-reasoned responses, which is particularly useful for tasks that involve problem-solving or detailed explanations. This approach not only enhances the clarity of the generated text but also helps in verifying the accuracy of the responses by providing a transparent view of the model’s reasoning process.

Function Calling on OpenAI vs Llama

Function calling capabilities differ between OpenAI’s models and Meta’s Llama models. OpenAI’s models, such as GPT-4, offer advanced function calling features through their API, allowing integration with external functions or services. This capability enables the models to perform tasks beyond mere text generation, such as executing commands or querying databases.

On the other hand, Llama models from Meta have their own set of function calling mechanisms, which might differ in implementation and scope. While both types of models support function calling, the specifics of their integration, performance, and functionality can vary. Understanding these differences is crucial for selecting the appropriate model for applications requiring complex interactions with external systems or specialized function-based operations.

Finding LLMs for Your Application

Choosing the right Large Language Model (LLM) for your application requires assessing its capabilities, scalability, and how well it meets your specific data and integration needs.

It is good to refer to performance benchmarks on various large language models (LLMs) across different series like Baichuan, ChatGLM, DeepSeek, and InternLM2. Here. evaluating their performance based on context length and needle count. This helps in getting an idea of which LLMs to choose for certain tasks.

Selecting the right Large Language Model (LLM) for your application involves evaluating factors such as the model’s capabilities, data handling requirements, and integration potential. Consider aspects like the model’s size, fine-tuning options, and support for specialized functions. Matching these attributes to your application’s needs will help you choose an LLM that provides optimal performance and aligns with your specific use case.

The LMSYS Chatbot Arena Leaderboard is a crowdsourced platform for ranking large language models (LLMs) through human pairwise comparisons. It displays model rankings based on votes, using the Bradley-Terry model to assess performance across various categories.

Conclusion

In summary, LLMs are evolving with advancements like function calling and retrieval-augmented generation (RAG). These improve their abilities by adding structured outputs and real-time data retrieval. While LLMs show great potential, their limitations in accuracy and real-time updates highlight the need for further refinement. Techniques like constrained generation, lowering temperature, and chain of thought reasoning help enhance the reliability and relevance of their outputs. These advancements aim to make LLMs more effective and accurate in various applications.

Understanding the differences between function calling in OpenAI and Llama models helps in choosing the right tool for specific tasks. As LLM technology advances, tackling these challenges and using these techniques will be key to improving their performance across different domains. Leveraging these distinctions will optimize their effectiveness in varied applications.

Frequently Asked Questions