# https://console.groq.com llms.txt

- [🗂️ LlamaIndex 🦙](https://console.groq.com/docs/llama-index): The 🗂️ LlamaIndex 🦙 page provides documentation and resources for utilizing LlamaIndex, a data framework designed to support LLM-based applications with context augmentation capabilities. This page offers information on integrating LlamaIndex with various programming languages, including Python and JavaScript, to enhance text generation accuracy and reliability.
- [Rate Limits](https://console.groq.com/docs/rate-limits): This documentation page, "Rate Limits", provides information on the control measures in place to regulate API access frequency, ensuring service stability and fair usage. It outlines the types of rate limits, how they are measured, and how to handle exceeded limits, including viewing limit information and handling HTTP status code 429 responses.
- [Speech to Text](https://console.groq.com/docs/speech-to-text): The "Speech to Text" documentation page provides an overview of the Groq API's speech-to-text solution, including its capabilities, API endpoints, and supported models for integrating high-quality audio processing into applications. This page serves as a guide for developers to understand and utilize the Groq API's speech-to-text features, including transcriptions and translations, to enhance their applications.
- [CrewAI + Groq: High-Speed Agent Orchestration](https://console.groq.com/docs/crewai): This documentation page provides an overview of the integration between CrewAI and Groq, enabling high-speed agent orchestration for complex tasks and sophisticated workflows. It offers a step-by-step guide to getting started with CrewAI and Groq, including a Python quick start example and a challenge to extend the code with additional agent functionality.
- [Introduction to Tool Use](https://console.groq.com/docs/tool-use): This documentation page, "Introduction to Tool Use", provides an overview of the tool use feature in Large Language Models (LLMs) and its capabilities, including interacting with external resources and performing real-world actions. It serves as a guide for developers to understand and integrate tool use with the Groq API, enabling them to build powerful applications with dynamic data and real-time use cases.
- [Toolhouse 🛠️🏠](https://console.groq.com/docs/toolhouse): The Toolhouse documentation page provides a comprehensive guide to equipping Large Language Models (LLMs) with various tools, such as Code Interpreter, Web Search, and Email tools, to enhance their functionality. This page offers step-by-step instructions and code examples to help users integrate Toolhouse with their LLMs and create custom tools for improved performance.
- [Content Moderation](https://console.groq.com/docs/content-moderation): This documentation page provides information on content moderation for Large Language Models (LLMs), including the use of Llama Guard 3, a powerful safeguard model designed to detect and filter harmful or unwanted content. The page covers the features, usage, and capabilities of Llama Guard 3, as well as its role in ensuring responsible and safe use of LLMs.
- [xRx + Groq: Easily Build Rich Multi-Modal Experiences](https://console.groq.com/docs/xrx): This documentation page provides a guide on how to easily build rich multi-modal experiences using xRx, an open-source framework for building AI-powered applications that interact with users across multiple modalities. It offers a quick start guide, sample apps collection, and a voice-enabled math tutor example to help developers get started with creating sophisticated AI systems.
- [Prompting for AI Models on Groq](https://console.groq.com/docs/prompting): This documentation page provides guidance on effective prompting strategies for AI models on Groq, including best practices for clarity, explicit instructions, and temperature settings. It outlines actionable techniques for crafting structured queries, leveraging system and user prompts, and optimizing output quality to get the most out of AI models hosted on Groq.
- [🦜️🔗 LangChain + Groq](https://console.groq.com/docs/langchain): This page provides documentation on integrating LangChain, a framework for building applications with large language models (LLMs), with Groq, a platform offering fast inference speed, to create sophisticated LLM-based applications. By combining LangChain's components, such as chains and prompt templates, with Groq's API, developers can leverage the strengths of both platforms to build powerful and efficient LLM applications.
- [Assistant Message Prefilling](https://console.groq.com/docs/prefilling): This documentation page, "Assistant Message Prefilling", provides guidance on how to control model output by prefilling `assistant` messages, allowing for more directed and formatted responses. It covers techniques, examples, and tips for effectively using this feature to achieve specific output formats and consistency in conversations.
- [Flex Processing](https://console.groq.com/docs/flex-processing): The "Flex Processing" documentation page provides information on a service tier designed for high-throughput workloads that prioritizes fast inference and can handle occasional request failures. This page explains the features, availability, and usage of Flex Processing, including its service tiers, parameters, and example usage.
- [Chat Completion Models](https://console.groq.com/docs/text-chat): The "Chat Completion Models" page provides documentation on the Groq Chat Completions API, which generates output responses based on a series of messages and can perform multi-turn discussions or single-interaction tasks. This page covers various topics, including JSON mode, SDK integration, and error handling, to help users effectively utilize the chat completion models.
- [Databricks MLflow + Groq: Open-Source GenAI Observability](https://console.groq.com/docs/databricks): This documentation page provides an overview of the integration between Databricks MLflow and Groq, offering open-source observability for Generative AI (GenAI) applications through features such as tracing dashboards and automated tracing. The page guides users through the setup and usage of this integration, enabling them to monitor and optimize their GenAI models with ease.
- [Groq client libraries](https://console.groq.com/docs/libraries): The Groq client libraries page provides documentation and resources for using Groq's official client libraries, including Python and JavaScript/Typescript libraries, to interact with the Groq REST API. This page also lists community-built libraries for other programming languages, such as C#, Dart/Flutter, PHP, and Ruby, which can be used to integrate Groq into various applications.
- [Models: Models (tsx)](https://console.groq.com/docs/models/models): This page provides a comprehensive list of models, including their specifications and links to model cards, for both production and preview models. The models are organized by their respective developers, such as Meta, HuggingFace, and OpenAI, and include details like context window, max completion tokens, and max file size.
- [Supported Models](https://console.groq.com/docs/models): The "Supported Models" page provides a comprehensive list of models currently supported by GroqCloud, including production, preview, and deprecated models, to help users choose the right model for their needs. This page serves as a reference guide for users to determine which models are suitable for production environments, evaluation purposes, or have been deprecated.
- [Vision](https://console.groq.com/docs/vision): The "Vision" documentation page provides information on using Groq API's multimodal models for understanding and interpreting visual data from images, enabling fast inference and low latency for tasks such as visual question answering and image processing. This page covers supported models, usage guidelines, and technical details for integrating vision capabilities into applications.
- [Arize + Groq: Open-Source AI Observability](https://console.groq.com/docs/arize): This documentation page provides a guide on integrating Arize's open-source AI observability library, Arize Phoenix, with Groq-powered applications to gain deep insights into AI workflow performance and behavior. It offers a step-by-step tutorial on setting up the integration, including installation, configuration, and example code to get started with tracing and monitoring AI applications.
- [Text to Speech](https://console.groq.com/docs/text-to-speech): The "Text to Speech" documentation page provides guidance on using the Groq API speech endpoint to generate lifelike audio from text, supporting 30 voices across English and Arabic languages. This page offers a comprehensive overview, including API endpoint details, supported models, and usage parameters to help developers integrate text-to-speech functionality into their applications.
- [Reasoning](https://console.groq.com/docs/reasoning): This documentation page, "Reasoning", provides information on using Groq's reasoning models for complex problem-solving tasks that require step-by-step analysis and logical deduction. It covers topics such as supported models, reasoning formats, and quick start guides to help users implement and utilize these models effectively.
- [Quickstart](https://console.groq.com/docs/quickstart): The Quickstart page provides a step-by-step guide to getting started with the Groq API, covering key setup and initial request processes. This page enables users to rapidly set up and begin using the Groq API, streamlining the onboarding process for developers.
- [🎨 Gradio + Groq: Easily Build Web Interfaces](https://console.groq.com/docs/gradio): This documentation page provides a guide on how to easily build web interfaces for your applications using Gradio and Groq, enabling the creation of interactive demos and shareable apps with features like interface builders and interactive demos. It offers a quick start guide, examples, and resources to help you get started with building robust applications with Gradio and Groq.
- [Groq Batch API](https://console.groq.com/docs/batch): The Groq Batch API documentation page provides information on how to process large-scale workloads asynchronously, allowing users to run thousands of API requests at scale with a 25% lower cost and higher rate limits. This page guides users through the process of getting started with the Batch API, including preparing batch files, submitting batch jobs, and retrieving results.
- [Qwen Qwq 32b: Model (tsx)](https://console.groq.com/docs/model/qwen-qwq-32b): This documentation page provides information on the Qwen Qwq 32b model (tsx), a 32-billion parameter reasoning model that delivers competitive performance on complex tasks. The page offers details on the model's capabilities, deployment, and performance, serving as a resource for developers and users working with the Qwen Qwq 32b model.
- [Qwen 2.5 Coder 32b: Model (tsx)](https://console.groq.com/docs/model/qwen-2.5-coder-32b): This documentation page provides information on the Qwen 2.5 Coder 32b model (tsx), a specialized version of Qwen 2.5-32B fine-tuned for code generation and development tasks. It offers details on the model's capabilities, built on 5.5 trillion tokens of code and technical content, and its production-quality code generation capabilities.
- [Llama3 70b 8192: Model (tsx)](https://console.groq.com/docs/model/llama3-70b-8192): This documentation page provides information about the Llama3 70b 8192 model, a reliable foundation model that excels at dialogue and content-generation tasks, offered through the Groq API. The page serves as a resource for developers and users looking to utilize this model for production-ready and cost-effective applications.
- [Llama 3.1 8b Instant: Model (tsx)](https://console.groq.com/docs/model/llama-3.1-8b-instant): This documentation page provides information on the Llama 3.1 8b Instant Model (tsx), a production-grade solution offering rapid response times and balanced efficiency for latency-sensitive applications. It covers the model's capabilities and suitability for various use cases, including chat interfaces, content filtering systems, and large-scale data processing workloads.
- [Llama 3.2 3b Preview: Model (tsx)](https://console.groq.com/docs/model/llama-3.2-3b-preview): This documentation page provides information about the LLaMA 3.2 3B Preview model, including its features, capabilities, and ideal applications. The page serves as a resource for developers and users looking to utilize this model for tasks such as content creation, summarization, and information retrieval.
- [Llama 3.3 70b Specdec: Model (tsx)](https://console.groq.com/docs/model/llama-3.3-70b-specdec): This documentation page provides information on the Llama 3.3 70B SpecDec model, a speculative decoding variant of Meta's Llama 3.3 70B model optimized for high-speed inference. The page is intended for users seeking to understand the capabilities and implementation of this model, particularly its suitability for real-time applications.
- [Llama3 8b 8192: Model (tsx)](https://console.groq.com/docs/model/llama3-8b-8192): This documentation page provides information about the Llama3 8b 8192 model, specifically its performance and capabilities on Groq hardware. It serves as a resource for understanding the model's features, benefits, and suitability for high-volume applications where speed and cost are crucial factors.
- [Mistral Saba 24b: Model (tsx)](https://console.groq.com/docs/model/mistral-saba-24b): This documentation page provides information about the Mistral Saba 24B model (tsx), a specialized multilingual model designed for various languages. It offers details on the model's capabilities, features, and performance across different languages, including Arabic, Farsi, Urdu, Hebrew, Indic languages, and English.
- [Qwen 2.5 32b: Model (tsx)](https://console.groq.com/docs/model/qwen-2.5-32b): This documentation page provides information about the Qwen 2.5 32b model (tsx), including its capabilities and features. It serves as a resource for understanding and utilizing Alibaba's flagship model, which offers near-instant responses and advanced language processing capabilities.
- [Deepseek R1 Distill Llama 70b: Model (tsx)](https://console.groq.com/docs/model/deepseek-r1-distill-llama-70b): This documentation page provides information about the DeepSeek R1 Distill Llama 70b model, including its capabilities and performance. The page serves as a resource for understanding the model's features and usage, particularly in relation to mathematical and logical reasoning tasks.
- [PlayAI Dialog v1.0 Model Card](https://console.groq.com/docs/model/playai-tts): The "PlayAI Dialog v1.0 Model Card" documentation page provides an overview of the PlayAI Dialog model, including its architecture, training data, key features, and performance metrics. This page serves as a comprehensive resource for understanding the capabilities and limitations of the PlayAI Dialog v1.0 model, designed for creative content generation, interactive storytelling, and narrative development.
- [Llama Guard 3 8b: Model (tsx)](https://console.groq.com/docs/model/llama-guard-3-8b): This documentation page provides information on the Llama Guard 3 8B model, a specialized content moderation model built on the Llama framework. It outlines the model's capabilities and Groq's support for fast inference, making it a resource for developers using the model for content moderation applications.
- [Deepseek R1 Distill Qwen 32b: Model (tsx)](https://console.groq.com/docs/model/deepseek-r1-distill-qwen-32b): This documentation page provides information about the DeepSeek R1 Distill Qwen 32b model, including its capabilities, features, and usage. The page serves as a resource for understanding and utilizing the model's advanced mathematical and logical reasoning capabilities, as well as its efficient performance and complex problem-solving abilities.
- [Deepseek R1 Distill Llama 70b Specdec: Model (tsx)](https://console.groq.com/docs/model/deepseek-r1-distill-llama-70b-specdec): This page provides information about the DeepSeek R1 Distill Llama 70B SpecDec model, a speculative decoding version of DeepSeek's R1 model fine-tuned from the Llama-3.3-70B-SpecDec base model. It offers details on the model's capabilities, including its ability to deliver exceptional performance on mathematical and logical reasoning tasks with significantly faster response times.
- [Llama 3.2 1b Preview: Model (tsx)](https://console.groq.com/docs/model/llama-3.2-1b-preview): This documentation page provides an overview of the LLaMA 3.2 1B Preview model, including its key features, capabilities, and use cases. It serves as a resource for developers and users looking to leverage this model for cost-sensitive, high-throughput applications, such as text analysis and content summarization.
- [LiveKit + Groq: Build End-to-End AI Voice Applications](https://console.groq.com/docs/livekit): This documentation page provides a guide on integrating LiveKit with Groq to build end-to-end AI voice applications, leveraging LiveKit's text-to-speech and real-time communication features alongside Groq's high-performance speech recognition capabilities. The page offers a step-by-step quick start guide to help developers get started with building AI voice applications using this integration.
- [Agno + Groq: Lightning Fast Agents](https://console.groq.com/docs/agno): This documentation page, "Agno + Groq: Lightning Fast Agents", provides a guide on building and utilizing multi-modal agents with the Agno framework and Groq models to achieve tasks such as web search, image understanding, and reasoning. It includes tutorials, code examples, and explanations to help developers create autonomous agents that can solve problems by running tools, accessing knowledge, and memory to improve responses.
- [API Error Codes and Responses](https://console.groq.com/docs/errors): This documentation page, "API Error Codes and Responses", provides a comprehensive guide to understanding the various error codes and responses returned by the API, helping developers effectively handle errors and debug their applications. It covers standard HTTP response status codes, error codes, and response bodies, as well as explanations of each code and example response bodies to aid in troubleshooting.
- [Composio](https://console.groq.com/docs/composio): The Composio page provides documentation and resources for managing and integrating tools with Large Language Models (LLMs) and AI agents, enabling the creation of fast and seamless interactions with external applications. This page offers a step-by-step guide, code examples, and links to additional resources to help users build and deploy Composio-enabled Groq agents.
- [Overview](https://console.groq.com/docs/overview): The Overview page provides a starting point for developers to learn about and integrate Groq's fast LLM inference and OpenAI-compatible API into their applications. This page offers a brief introduction to the platform, its features, and resources to help developers get started with building and scaling their apps.
- [✨ Vercel AI SDK + Groq: Rapid App Development](https://console.groq.com/docs/ai-sdk): This documentation page provides a guide on using the Vercel AI SDK with Groq for rapid app development, enabling developers to build scalable and high-speed applications with advanced language models. By following the tutorials and examples on this page, developers can create powerful applications, such as chat interfaces and natural language generation tools, with ease.
- [E2B + Groq: Open-Source Code Interpreter](https://console.groq.com/docs/e2b): This documentation page provides an overview and guide for using the E2B + Groq open-source code interpreter, which enables secure and sandboxed execution of code generated by large language models (LLMs) via the Groq API. The page includes a Python quick start tutorial, code examples, and resources for building applications that generate and execute code in real-time.
- [🚅 LiteLLM + Groq for Production Deployments](https://console.groq.com/docs/litellm): This documentation page provides a guide for production deployments using LiteLLM and Groq, offering features such as cost management, smart caching, and spend tracking to optimize resource utilization. It includes a quick start section and links to advanced setup and tutorials for building production-ready applications with LiteLLM and Groq.
- [AutoGen + Groq: Building Multi-Agent AI Applications](https://console.groq.com/docs/autogen): This documentation page provides a guide on building multi-agent AI applications using AutoGen and Groq, enabling the creation of sophisticated AI agents that work together to solve complex tasks. It covers key features, including multi-agent orchestration, tool integration, and code generation, as well as step-by-step instructions for getting started with a Python quick start example.
- [OpenAI Compatibility](https://console.groq.com/docs/openai): This documentation page provides information on the compatibility of Groq API with OpenAI's client libraries, including configuration instructions and details on currently unsupported features. It serves as a guide for users to integrate their existing OpenAI applications with Groq API and provides feedback mechanisms for requesting support for additional features.
- [JigsawStack 🧩](https://console.groq.com/docs/jigsawstack): The JigsawStack documentation page provides an overview of the JigsawStack AI SDK, a powerful tool for integrating Large Language Models (LLMs) into backend applications to automate tasks such as web scraping and translation. This page serves as a resource for developers to learn about the features and capabilities of JigsawStack, including the Prompt Engine and its various features for optimizing performance and ensuring safety.
- [Groq API Reference](https://console.groq.com/docs/api-reference): The Groq API Reference page provides a comprehensive overview of the available APIs, including their endpoints, parameters, and response formats, to help developers integrate Groq functionality into their applications. This reference guide serves as a technical resource for developers to explore and utilize the full capabilities of the Groq API.