Change
fcc11dc
fcc11dcda77b208a99abd52ae258cbf336687364 · commit on GitHub
groq-llms-full-txt: changed (797252 bytes, HTTP 200)
raw/groq-llms-full-txt/response.txt added
- Source
- groq-llms-full-txt
- Lines added
- +23,243
- Lines removed
- -0
- Stored bytes at this commit
- 797,252
- Timestamp
- origin
- Raw artifact at this commit
- raw/groq-llms-full-txt/response.txt
Recorded headers
| observed_at | 2026-08-26T20:25:38.772Z |
|---|---|
| origin_date | 2026-08-26T06:24:41.000Z |
| status | 200 |
| final URL | https://console.groq.com/llms-full.txt |
| etag | W/"d598ff05541fb0f41a28ad3e046e43cf" |
| last-modified | Wed, 26 Aug 2026 06:24:41 GMT |
| date | Wed, 26 Aug 2026 20:25:38 GMT |
| age | 50457 |
| cache-control | public, max-age=0, must-revalidate |
| cf-cache-status | DYNAMIC |
| content-encoding | br |
| content-length | null |
@
@@ -0,0 +1,23243 @@+
# https://console.groq.com llms-full.txt+
+
## Script: Code Examples (ts)+
+
URL: https://console.groq.com/docs/scripts/code-examples+
+
```javascript+
export const getExampleCode = (+
modelId: string,+
content = "Explain why fast inference is critical for reasoning models",+
) => ({+
shell: `curl https://api.groq.com/openai/v1/chat/completions \\+
-H "Authorization: Bearer $GROQ_API_KEY" \\+
-H "Content-Type: application/json" \\+
-d '{+
"model": "${modelId}",+
"messages": [+
{+
"role": "user",+
"content": "${content}"+
}+
]+
}'`,+
+
javascript: `import Groq from "groq-sdk";+
const groq = new Groq();+
async function main() {+
const completion = await groq.chat.completions.create({+
model: "${modelId}",+
messages: [+
{+
role: "user",+
content: "${content}",+
},+
],+
});+
console.log(completion.choices[0]?.message?.content);+
}+
main().catch(console.error);`,+
+
python: `from groq import Groq+
client = Groq()+
completion = client.chat.completions.create(+
model="${modelId}",+
messages=[+
{+
"role": "user",+
"content": "${content}"+
}+
]+
)+
print(completion.choices[0].message.content)`,+
+
json: `{+
"model": "${modelId}",+
"messages": [+
{+
"role": "user", +
"content": "${content}"+
}+
]+
}`,+
});+
```+
+
---+
+
## Script: Types.d (ts)+
+
URL: https://console.groq.com/docs/scripts/types.d+
+
declare module "*.sh" {+
const content: string;+
export default content;+
}+
+
---+
+
## JigsawStack 🧩+
+
URL: https://console.groq.com/docs/jigsawstack+
+
## JigsawStack 🧩+
+
<br />+
+
[JigsawStack](https://jigsawstack.com/) is a powerful AI SDK designed to integrate into any backend, automating tasks such as web scraping, Optical Character Recognition (OCR), translation, and more, using +
Large Language Models (LLMs). By plugging JigsawStack into your existing application infrastructure, you can offload the heavy lifting and focus on building.+
+
The [JigsawStack Prompt Engine]() is a feature that allows you to not only leverage LLMs but automatically choose the best LLM for every one of your prompts, delivering fast inference speed and performance+
powered by Groq with features including:+
+
- **Mixture-of-Agents (MoA) Approach:** Automatically selects optimized LLMs for your task, combining outputs for higher quality and faster results.+
- **Prompt Caching:** Optimizes performance for repeated prompt runs.+
- **Automatic Prompt Optimization:** Improves performance without manual intervention.+
- **Response Schema Validation:** Ensures accuracy and consistency in outputs.+
+
The Propt Engine also comes with a built-in prompt guard feature via Llama Guard 3 powered by Groq, which helps prevent prompt injection and a wide range of unsafe categories when activated, such as:+
- Privacy Protection+
- Hate Speech Filtering+
- Sexual Content Blocking+
- Election Misinformation Prevention+
- Code Interpreter Abuse Protection+
- Unauthorized Professional Advice Prevention+
+
<br />+
+
To get started, refer to the JigsawStack documentation [here](https://docs.jigsawstack.com/integration/groq) and learn how to set up your Prompt +
Engine [here](https://github.com/groq/groq-api-cookbook/tree/main/tutorials/jigsawstack-prompt-engine).+
+
---+
+
## Groq API Reference+
+
URL: https://console.groq.com/docs/api-reference+
+
# Groq API Reference+
+
---+
+
## Parallel + Groq: Fast Web Search for Real-Time AI Research+
+
URL: https://console.groq.com/docs/parallel+
+
## Parallel + Groq: Fast Web Search for Real-Time AI Research+
+
[Parallel](https://parallel.ai) provides a web search MCP server that gives AI models access to real-time web data. Combined with Groq's industry-leading inference speeds (1000+ tokens/second), you can build research agents that find and analyze current information in seconds, not minutes.+
+
**Key Features:**+
- **Real-Time Information:** Access current events, breaking news, and live data+
- **Parallel Processing:** Search multiple sources simultaneously+
- **Ultra-Fast:** Groq's inference makes tool calling nearly instant+
- **Source Transparency:** See exactly which websites were searched+
- **Accurate Results:** Fresh data means current answers, not outdated information+
+
## Quick Start+
+
#### 1. Install the required packages:+
```bash+
pip install openai python-dotenv+
```+
+
#### 2. Get your API keys:+
- **Groq:** [console.groq.com/keys](https://console.groq.com/keys)+
- **Parallel:** [platform.parallel.ai](https://platform.parallel.ai)+
+
```bash+
export GROQ_API_KEY="your-groq-api-key"+
export PARALLEL_API_KEY="your-parallel-api-key"+
```+
+
#### 3. Create your first real-time research agent:+
+
```python parallel_research.py+
import os+
from openai import OpenAI+
from openai.types import responses as openai_responses+
+
client = OpenAI(+
base_url="https://api.groq.com/api/openai/v1",+
api_key=os.getenv("GROQ_API_KEY")+
)+
+
tools = [+
openai_responses.tool_param.Mcp(+
server_label="parallel_web_search",+
server_url="https://mcp.parallel.ai/v1beta/search_mcp/",+
headers={"x-api-key": os.getenv("PARALLEL_API_KEY")},+
type="mcp",+
require_approval="never",+
)+
]+
+
response = client.responses.create(+
model="openai/gpt-oss-120b",+
input="What does Anthropic do? Find recent product launches from past year.",+
tools=tools,+
temperature=0.1,+
top_p=0.4,+
)+
+
print(response.output_text)+
```+
+
## Advanced Examples+
+
### Multi-Company Comparison+
+
Compare multiple companies side-by-side:+
+
```python company_comparison.py+
companies = ["OpenAI", "Anthropic", "Google AI", "Meta AI"]+
+
for company in companies:+
response = client.responses.create(+
model="openai/gpt-oss-120b",+
input=f"""Research {company}:+
- Main products+
- Latest announcements (6 months)+
- Company size and funding+
- Key differentiators""",+
tools=tools,+
temperature=0.1,+
)+
print(f"{company}:\n{response.output_text}\n")+
```+
+
### Real-Time Market Data+
+
Get current financial information:+
+
```python market_data.py+
stocks = ["GOOGL", "MSFT", "NVDA", "TSLA"]+
+
for ticker in stocks:+
response = client.responses.create(+
model="openai/gpt-oss-120b",+
input=f"Current stock price of {ticker}? Include today's change and 52-week range.",+
tools=tools,+
temperature=0.1,+
)+
print(f"{ticker}: {response.output_text}")+
```+
+
### Breaking News Monitoring+
+
Track developing stories:+
+
```python news_monitoring.py+
topics = [+
"artificial intelligence breakthroughs",+
"quantum computing developments",+
"renewable energy innovations"+
]+
+
for topic in topics:+
response = client.responses.create(+
model="openai/gpt-oss-120b",+
input=f"Latest breaking news about {topic} from today?",+
tools=tools,+
temperature=0.1,+
)+
print(f"{topic}:\n{response.output_text}\n")+
```+
+
## Performance Comparison+
+
Real comparison from testing:+
- **Groq (openai/gpt-oss-120b):** 11.15s, 472 chars/sec+
- **OpenAI (gpt-5):** 88.38s, 42 chars/sec+
+
**Groq is 8x faster** due to LPU architecture, instant tool call decisions, and fast synthesis of search results.+
+
**Challenge:** Build a real-time market intelligence platform that monitors news, tracks competitor activities, analyzes trends, compares products, and generates daily briefings!+
+
## Additional Resources+
+
- [Parallel Documentation](https://docs.parallel.ai)+
- [Parallel Platform](https://platform.parallel.ai)+
- [Groq Responses API](https://console.groq.com/docs/api-reference#responses)+
+
---+
+
## Security Onboarding+
+
URL: https://console.groq.com/docs/production-readiness/security-onboarding+
+
# Security Onboarding+
+
Welcome to the **Groq Security Onboarding** guide. +
This page walks through best practices for protecting your API keys, securing client configurations, and hardening integrations before moving into production.+
+
## Overview+
+
Security is a shared responsibility between Groq and our customers. +
While Groq ensures secure API transport and service isolation, customers are responsible for securing client-side configurations, keys, and data handling.+
+
All Groq API traffic is encrypted in transit using TLS 1.2+ and authenticated via API keys.+
+
## Secure API Key Management+
+
Never expose or hardcode API keys directly into your source code. +
Use environment variables or a secret management system.+
+
**Warning:** Never embed keys in frontend code or expose them in browser bundles. If you need client-side usage, route through a trusted backend proxy.+
+
## Key Rotation & Revocation+
+
* Rotate API keys periodically (e.g., quarterly).+
* Revoke keys immediately if compromise is suspected.+
* Use per-environment keys (dev / staging / prod).+
* Log all API key creations and deletions.+
+
## Transport Security (TLS)+
+
Groq APIs enforce HTTPS (TLS 1.2 or higher).+
You should **never** disable SSL verification.+
+
## Input and Prompt Safety+
+
When integrating Groq into user-facing systems, ensure that user inputs cannot trigger prompt injection or tool misuse.+
+
**Recommendations:**+
+
* Sanitize user input before embedding in prompts.+
* Avoid exposing internal system instructions or hidden context.+
* Validate model outputs (especially JSON / code / commands).+
* Limit model access to safe tools or actions only.+
+
## Rate Limiting and Retry Logic+
+
Implement client-side rate limiting and exponential backoff for 429 / 5xx responses.+
+
## Logging & Monitoring+
+
Maintain structured logs for all API interactions.+
+
**Include:**+
+
* Timestamp+
* Endpoint+
* Request latency+
* Key / service ID (non-secret)+
* Error codes+
+
**Tip:** Avoid logging sensitive data or raw model responses containing user information.+
+
## Secure Tool Use & Agent Integrations+
+
When using Groq's **Tool Use** or external function execution features:+
+
* Expose only vetted, sandboxed tools.+
* Restrict external network calls.+
* Audit all registered tools and permissions.+
* Validate arguments and outputs.+
+
## Incident Response+
+
If you suspect your API key is compromised:+
+
1. Revoke the key immediately from the [Groq Console](https://console.groq.com/keys).+
2. Rotate to a new key and redeploy secrets.+
3. Review logs for suspicious activity.+
4. Notify your security admin.+
+
**Warning:** Never reuse compromised keys, even temporarily.+
+
## Resources+
+
- [Groq API Documentation](/docs/api-reference)+
- [Prompt Engineering Guide](/docs/prompting)+
- [Understanding and Optimizing Latency](/docs/production-readiness/optimizing-latency)+
- [Production-Ready Checklist](/docs/production-readiness/production-ready-checklist)+
- [Groq Developer Community](https://community.groq.com)+
- [OpenBench](https://openbench.dev)+
+
<br/>+
+
*This security guide should be customized based on your specific application requirements and updated based on production learnings.*+
+
---+
+
## Production-Ready Checklist for Applications on GroqCloud+
+
URL: https://console.groq.com/docs/production-readiness/production-ready-checklist+
+
# Production-Ready Checklist for Applications on GroqCloud+
+
Deploying LLM applications to production involves critical decisions that directly impact user experience, operational costs, and system reliability. **This comprehensive checklist** guides you through the essential steps to launch and scale your Groq-powered application with confidence.+
+
From selecting the optimal model architecture and configuring processing tiers to implementing robust monitoring and cost controls, each section addresses the common pitfalls that can derail even the most promising LLM applications.+
+
## Pre-Launch Requirements+
+
### Model Selection Strategy+
+
* Document latency requirements for each use case+
* Test quality/latency trade-offs across model sizes+
* Reference the Model Selection Workflow in the Latency Optimization Guide+
+
### Prompt Engineering Optimization+
+
* Optimize prompts for token efficiency using context management strategies+
* Implement prompt templates with variable injection+
* Test structured output formats for consistency+
* Document optimization results and token savings+
+
### Processing Tier Configuration+
+
* Reference the Processing Tier Selection Workflow in the Latency Optimization Guide+
* Implement retry logic for Flex Processing failures+
* Design callback handlers for Batch Processing+
+
## Performance Optimization+
+
### Streaming Implementation+
+
* Test streaming vs non-streaming latency impact and user experience+
* Configure appropriate timeout settingsDiff display stops at 400 lines. The line counts above are from the whole diff. The raw artifact at this commit is linked above.