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

- [🗂️ LlamaIndex 🦙](https://console.groq.com/docs/llama-index): The 🗂️ LlamaIndex 🦙 page provides documentation for a data framework designed to support LLM-based applications, particularly those utilizing Retrieval-Augmented Generation (RAG) systems. This page offers resources and guides for integrating LlamaIndex with various programming languages, including Python and JavaScript.
- [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 response headers.
- [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, a framework for orchestrating multiple AI agents, and Groq, a high-speed inference platform, enabling fast and scalable autonomous decision-making and collaboration. The page guides users through the process of leveraging Groq's fast inference to optimize CrewAI agent teams and create sophisticated workflows.
- [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), which enables interaction with external resources to gather dynamic data and perform real-world actions. It covers the basics of tool use, supported models, and how to integrate tools with the Groq API.
- [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 capabilities, usage, and harm taxonomy of Llama Guard 3, helping developers and platform administrators ensure 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 creating 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 building immersive experiences.
- [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 Groq's fast inference speed capabilities.
- [🦜️🔗 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 leverage components like chains, prompt templates, and memory for sophisticated application development. By combining LangChain with the Groq API, developers can create autonomous systems and extend LLM applications with external capabilities.
- [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 best practices for utilizing this feature to achieve specific output formats and conversation consistency.
- [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, as well as its comparison to other service tiers, to help users optimize their workload processing.
- [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, generating chat completions, and streaming, to help users effectively utilize the API.
- [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 like 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.
- [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 access 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 documentation page, "Models: Models (tsx)", provides an overview of the available models, including their specifications and links to model cards, categorized into production and preview models. The page serves as a reference for users to explore and understand the capabilities and limitations of each model.
- [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 best 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 require migration to alternative models.
- [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, including supported models and usage guidelines. This page serves as a resource for developers to integrate vision capabilities into their applications using Groq API's fast inference and low latency features.
- [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 LLM workflow performance and behavior. It offers a step-by-step tutorial on setting up the integration, including installation, configuration, and example code, to enable comprehensive tracing and monitoring of 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 examples 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 reasoning models for complex problem-solving tasks, including model capabilities, supported models, and configuration options. It serves as a guide for developers to integrate and utilize reasoning models in their applications, with a focus on achieving instant reasoning capabilities through Groq's inference speed.
- [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 steps to help you begin using the API quickly. This page is designed to have you up and running with the Groq API in just a few minutes, with links to additional resources for further exploration and support.
- [🎨 Gradio + Groq: Easily Build Web Interfaces](https://console.groq.com/docs/gradio): This 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 tutorial, 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 no impact to standard rate limits. This page serves as a guide for developers to get 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 about 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 those looking to understand and utilize 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 (tsx), a reliable foundation model that excels at dialogue and content-generation tasks. It serves as a resource for understanding the model's capabilities, performance, and usage via the Groq API.
- [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 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 version of Meta's Llama 3.3 70B model optimized for high-speed inference. The page serves as a resource for understanding the capabilities and applications of this model, particularly in real-time scenarios.
- [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 and suitability for high-volume applications where speed and cost-efficiency are crucial.
- [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. The page offers details on the model's capabilities, features, and performance, serving as a resource for developers and users working with the Mistral Saba 24B model.
- [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, a distilled version of DeepSeek's R1 model fine-tuned from the Llama-3.3-70B-Instruct base model. The page serves as a resource for understanding the model's capabilities, including its robust reasoning capabilities and exceptional performance on 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 developers and users to understand the capabilities and limitations of the PlayAI Dialog v1.0 model.
- [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.
- [Deepseek R1 Distill Llama 70b Specdec: Model (tsx)](https://console.groq.com/docs/model/deepseek-r1-distill-llama-70b-specdec): This documentation page provides information on 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. The page offers details on the model's capabilities, including its 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 information about the LLaMA 3.2 1B Preview model, including its capabilities, applications, and benefits. It serves as a resource for developers and users looking to utilize 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 Groq's speech recognition capabilities and LiveKit's text-to-speech and real-time communication features. It offers a step-by-step quick start process to get started with building AI voice applications using LiveKit and Groq.
- [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, enabling the creation of various agent types such as agentic RAG, image agents, and reasoning agents. It includes a Python quick start section and examples of agent teams to help users get started with building their own agents.
- [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 and handling errors that may occur when interacting with the API, including standard HTTP response status codes and custom error codes. It offers detailed explanations and examples of error codes, response bodies, and error object structures to aid in effective error handling and debugging.
- [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 integrating Vercel's AI SDK with Groq for rapid app development, enabling developers to build scalable and high-speed applications powered by advanced language models. By following the tutorials and examples on this page, developers can create a variety of applications, including chat interfaces and natural language generation tools, with ease and efficiency.
- [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 and resources for building applications with E2B and Groq, targeting AI data analysts, coding applications, and reasoning-heavy agents.
- [🚅 LiteLLM + Groq for Production Deployments](https://console.groq.com/docs/litellm): This 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 documentation 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 features such as multi-agent orchestration, tool integration, and flexible workflows, along with step-by-step instructions and code examples to get started.
- [OpenAI Compatibility](https://console.groq.com/docs/openai): This 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 Groq API with their existing OpenAI applications 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, its features, and its capabilities, including the JigsawStack Prompt Engine and its various tools for automating tasks and optimizing performance. This page serves as a resource for developers looking to integrate JigsawStack into their applications and leverage its powerful AI capabilities.
- [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.