कितने बार आपको बैकएण्ड एपीआई्स के लिए इंतज़ार करना बंद कर दिया गया है?
प्रविष्ट करें mostlylucid.mockllmapi - एक उत्पादन को तैयार करने और कॉल राज्य की याद रखने के लिए।
क्या यह समर्थन करता है: हर प्रोटोकॉल आप की जरूरत है - RPREPC, gPC, SPC, SPRC, SPR, सर्वर-SC घटनाओं, और खोलें MPPEPEPEPEC. निश्चित रूप से प्रतिक्रियाओं को अपने संदर्भ पर आधारित किया जाता है, बहु-प्रयोगी कार्य कार्य और जटिल जाँच सरल बना रहे हैं.
आप ज़्यादातर का उपयोग तीन तरीकों से कर सकते हैं, पर निर्भर करता है कि आप किस तरह के पृथक वातावरण को चाहते हैं:
वेस्टर्न पूरा मार्गदर्शक: एपीआई संदर्भ दस्तावेज़ीकरण
पारंपरिक हंसी के लिए एक गंभीर गलती है: प्रत्येक अनुरोध स्वतंत्र है. आईडी 42 के साथ एक उपयोक्ता प्राप्त करें, फिर उनके आदेशों को लाने के लिए, और आप प्रयोक्ता ID 99 के लिए आदेश मिलेगा. कोई सुसंगतता नहीं है.
एपीआई संदर्भ इस साझा मेमोरी को संबंधित निवेदन के पार हल करें:
// Request 1: Get a user
// Note: 'context' is a simple query parameter - no cookies or sessions needed
fetch('/api/users/123?context=checkout-session')
// Response: { id: 42, name: "Alice Smith", email: "[email protected]" }
// Request 2: Get orders (same context parameter)
fetch('/api/orders?userId=42&context=checkout-session')
// Response: { userId: 42, customerName: "Alice Smith", items: [...] }
// Perfect! Same user, consistent data
LLM एक ही संदर्भ में पिछले निवेदनों को देखता है और सतत डाटा बनाता है. यह बहु- चरण कार्य प्रवाह के लिए खेल- बदलावकर्ता है.
विशेषताएँ:
उठने की संभावना:
व्यवहार:
सुरक्षा:
केस इस्तेमाल करें:
dotnet add package mostlylucid.mockllmapi
// Program.cs
builder.Services.AddLLMockApi(builder.Configuration);
app.MapLLMockApi("/api/mock");
# Download from https://github.com/scottgal/LLMApi/releases
llmock serve --port 5000
वेस्टर्न पूर्ण मार्गदर्शक: डॉक लेसर मार्गदर्शन
git clone https://github.com/scottgal/LLMApi.git
cd LLMApi
docker compose up -d
आप की जरूरत है एक का: ओलमा, ओपन - रीडला, या LM छात्रियो:
# Recommended: Ollama with ministral-3:3b (ultra-fast, accurate JSON generation)
ollama pull ministral-3:3b
देखें ओसमा मॉडल्स मार्गदर्शक सभी आदर्श सलाह और तुलनाओं के लिए
एक बार चल रहा है, अपनी पहली गुज़ारिश कीजिए:
curl http://localhost:5000/api/mock/users
# Response: [{"id": 1, "name": "Alice Johnson", "email": "[email protected]"}, ...]
यही कारण है कि अब आप एक काम कर रहे एपीआई है जो माँग पर यथार्थवादी डेटा बनाता है।
इस ब्लॉग से वास्तविक सर्च कोड है - यह असक्रिय उत्पादन फ्रन्टएण्ड कोड हैउपहास के लिए आवश्यक कोई अनुकूलनशीलता नहीं:
// typeahead.js from mostlylucid.net
export function typeahead() {
return {
query: '',
results: [],
search() {
fetch(`/api/search/${encodeURIComponent(this.query)}`)
.then(response => response.json())
.then(data => { this.results = data; });
}
}
}
इसे हँसी में डाल दो:
# Using CLI
llmock serve --port 5000
# Query returns contextual results
curl http://localhost:5000/api/search/markdown
# LLM generates blog posts about Markdown
curl http://localhost:5000/api/search/docker
# LLM generates blog posts about Docker
हर जवाब अनोखा और यथार्थवादी है, और इस प्रश्न के अनुकूल है ।
सिर्फ बेतरतीब डेटा बनाने के अलावा, आपको अकसर JSON संरचना के ऊपर सटीक नियंत्रण की आवश्यकता होती है. आकार नियंत्रण आप वास्तव में क्या LLLM बता देता है - सामने के विकास के लिए सबसे शक्तिशाली सुविधा.
# Without shape - random structure
curl http://localhost:5000/api/mock/users
# Response: { "userId": 1, "fullName": "Alice" }
# With shape - you control it
curl "http://localhost:5000/api/mock/users" \
-H 'X-Response-Shape: {"id":0,"name":"string","email":"string"}'
# Response: { "id": 1, "name": "Alice", "email": "[email protected]" }
आकार निर्दिष्ट करने के लिए तीन तरीके:
?shape={...}X-Response-Shape: {...} (अनुशंसित){"shape": {...}}const shape = {
company: {
id: 0,
name: "string",
employees: [{
id: 0,
firstName: "string",
department: { id: 0, name: "string" },
projects: [{ id: 0, title: "string" }]
}]
}
};
fetch('/api/mock/company', {
headers: { 'X-Response-Shape': JSON.stringify(shape) }
});
interface User {
id: number;
name: string;
email: string;
}
const USER_SHAPE: Partial<User> = { id: 0, name: "", email: "" };
// Shape becomes your type definition AND mock schema!
अब चलो API संदर्भ को हैंडल करने के लिए tras के साथ आकार को जोड़ते हैं, विविध चरणों के फूल. संदर्भ मेमोरी सुविधा याद रखें पहले से? यहाँ है कैसे यह वास्तव में विश्वीय संचालन में प्रकाश।
यह उदाहरण ज़्यादातर क्विन्सन के अनुवाद सेवा से दिखाता है कि कैसे सीनेटएम पूर्ण अतुल्यकालिक कार्य प्रवाह के दौरान राज्य को बनाए रखता है:
# Step 1: Start translation
curl -X POST http://localhost:5000/api/translate/start?context=translate-session \
-d '{"language": "es", "markdown": "# Hello World"}'
# Response: { "taskId": "abc-123", "status": "processing" }
# Step 2: Check status (LLM remembers the task)
curl http://localhost:5000/api/translate/status/abc-123?context=translate-session
# Response: { "taskId": "abc-123", "status": "complete" }
# Step 3: Get result (same taskId!)
curl http://localhost:5000/api/translate/result/abc-123?context=translate-session
# Response: { "taskId": "abc-123", "translatedText": "# Hola Mundo" }
ध्यान दें कि कैसे taskId सभी निवेदनों के पार सतत है. संदर्भ यह संभव बनाता है.
अब तक हम Race पर ध्यान केंद्रित किया है, लेकिन आधुनिक अनुप्रयोग अधिक की जरूरत है. क्या आप ग्राफQL के साथ निर्माण कर रहे हैं, सिग्नलR के साथ असली समय विशेषताओं को लागू कर रहे हैं या gRCMC सेवा के साथ काम कर रहे हैं, ज़्यादातर uci.moli ने आपको कवरी पर कवर किया है.
समर्थित प्रोटोकॉलः
वेस्टर्न गाइड: ग्राफ
curl -X POST http://localhost:5000/api/mock/graphql \
-d '{"query": "{ users { id name email } }"}'
क्वैरी आकार है - कोई अलग स्कीमा आवश्यक नहीं.
वेस्टर्न पूर्ण मार्गदर्शक: सीपीसी समर्थन
# Upload .proto file
curl -X POST http://localhost:5116/api/grpc-protos \
--data-binary "@user_service.proto"
# Call via JSON or binary Protobuf
curl -X POST http://localhost:5116/api/grpc/userservice/UserService/GetUser \
-d '{"user_id": 123}'
वेस्टर्न गाइड: सिग्नल-आर डेमो गाइडGenericName
const connection = new signalR.HubConnectionBuilder()
.withUrl("/hub/mock")
.build();
connection.on("DataUpdate", (message) => {
console.log(message.data); // Live generated data
});
await connection.start();
await connection.invoke("SubscribeToContext", "stock-prices");
निर्माण के लिए बिल्कुल सही है.
वेस्टर्न गाइड: एसईईएस स्ट्रीमिंग मोड
const eventSource = new EventSource('/api/mock/stream/users');
eventSource.onmessage = (event) => {
const data = JSON.parse(event.data);
console.log('Token:', data.chunk); // Progressive generation
};
वेस्टर्न पूर्ण मार्गदर्शक: ओपनपीआई विशेषताएँ
# CLI: Load any OpenAPI spec
llmock serve --spec https://petstore3.swagger.io/api/v3/openapi.json
# All endpoints become live mocks automatically
curl http://localhost:5000/petstore/pet/123
वेस्टर्न पूर्ण मार्गदर्शक: औज़ार क्रियाएँ (O)
कभी - कभी आपको एक नयी - नयी जानकारी की ज़रूरत पड़ती है, साथ ही साथ उत्पादन से वास्तविक जानकारी की ज़रूरत होती है ।
{
"Tools": [{
"Name": "getUserData",
"Type": "http",
"HttpConfig": {
"Endpoint": "https://api.production.com/users/{userId}",
"Headers": { "Authorization": "Bearer ${PROD_API_KEY}" }
}
}]
}
curl "http://localhost:5000/api/mock/orders?useTool=getUserData&userId=123"
उपहास उपयोगकर्ता डाटा लाता है, फिर LLM इसके उपयोग से आदेश बनाता है. पैंक्रियाज़ के साथ यथार्थवादी जाँच के लिए अधिक उपयोगी है.
अगर आप एक अनजाने में निर्माण कर रहे हैं. वेर, एकीकरण है समुद्रीय है. इस तरह की खूबसूरती है शून्य कोड परिवर्तन आपके सेवाओं के लिए - आप बस कॉन्फ़िगर करें HttpClient विकास के दौरान और उत्पादन में वास्तविक एपीआई पर विचार करने के लिए ।
// Real code from mostlylucid.net
builder.Services.AddHttpClient<IMarkdownTranslatorService, MarkdownTranslatorService>(
client => {
var baseUrl = builder.Configuration["TranslationService:BaseUrl"]
?? "http://localhost:5000"; // Mock during dev
client.BaseAddress = new Uri(baseUrl);
}
);
एएस- एडिस्कमेंट्स. डी.सन:
{
"TranslationService": {
"BaseUrl": "http://localhost:5000" // Mock
}
}
एप्रेशन्स. prodin.jon:
{
"TranslationService": {
"BaseUrl": "https://api.production.com" // Real
}
}
यह पैटर्न किसी के लिए काम करता है HttpClient आपके अनुप्रयोग - अनुवाद सेवाओं में, भुगतान द्वार, बाहरी एपीआई्स, आप इसका नाम देते हैं ।
इससे पहले कि हम विस्तृत विशेषताओं में कटौती करें, हम इस उपकरण के बारे में स्पष्ट हो जब यह आपके काम फूल के लिए अर्थ बनाता है।
के लिए बिल्कुल सही:
इसके लिए कोई आदर्श नहीं:
अब आप जानते हैं कि यह कहाँ फिट है, चलो उन्नत क्षमताओं की जाँच करें.
इन सुविधाओं वैकल्पिक हैं - आप केवल बुनियादी बातों से अत्यधिक मूल्य प्राप्त कर सकते हैं. लेकिन जब आपको माप पर उत्पादन की जरूरत है, ये उपकरण यहाँ हैं.
वेस्टर्न गाइड: बहुल एमईएम बैकएण्ड
# Fast for dev
curl http://localhost:5000/api/mock/users
# High quality for demos
curl "http://localhost:5000/api/mock/users?backend=quality"
# Cloud AI for production-like
curl "http://localhost:5000/api/mock/users?backend=openai"
वेस्टर्न गाइड: पलटना व बैचिंग
जांच करें कि आपके एप्प्स दर सीमा कैसे हैंडल करता है:
{
"EnableRateLimiting": true,
"RateLimitDelayRange": "500-2000"
}
# Test 429 rate limiting
curl "http://localhost:5000/api/mock/users?error=429&errorMessage=Rate%20limit%20exceeded"
# Test 503 unavailable
curl "http://localhost:5000/api/mock/users?error=503"
सभी 4xx तथा 5x कोड समर्थन करता है.
# Generate and cache 10 variants
curl "http://localhost:5000/api/mock/users?shape={\"$cache\":10,\"id\":0,\"name\":\"string\"}"
सब्सक निवेदन तत्काल कैशेड जवाब मिलता है.
सबसे ऊपर की सभी विशेषताएँ विकास के लिए महान हैं, लेकिन क्या स्वचालित परीक्षण के बारे में? HttpClient बाकी करो.
dotnet add package mostlylucid.mockllmapi.Testing
using mostlylucid.mockllmapi.Testing;
// Create a client with a single endpoint configuration
var client = HttpClientExtensions.CreateMockLlmClient(
baseAddress: "http://localhost:5116",
pathPattern: "/users",
configure: endpoint => endpoint
.WithShape(new { id = 0, name = "", email = "" })
.WithCache(5)
);
// Make requests - configuration is automatically applied
var response = await client.GetAsync("/users");
var users = await response.Content.ReadFromJsonAsync<User[]>();
var client = HttpClientExtensions.CreateMockLlmClient(
"http://localhost:5116",
configure: handler => handler
.ForEndpoint("/users", config => config
.WithShape(new { id = 0, name = "", email = "" })
.WithCache(10))
.ForEndpoint("/posts", config => config
.WithShape(new { id = 0, title = "", content = "", authorId = 0 })
.WithCache(20))
.ForEndpoint("/error", config => config
.WithError(404, "Resource not found"))
);
// Each endpoint automatically uses its configuration
var usersResponse = await client.GetAsync("/users");
var postsResponse = await client.GetAsync("/posts");
var errorResponse = await client.GetAsync("/error"); // Returns 404
आकार कॉन्फ़िगरेशनः
// Using anonymous objects
.WithShape(new { id = 0, name = "", active = true })
// Using JSON strings
.WithShape("{ \"id\": 0, \"name\": \"\", \"tags\": [] }")
// Complex nested structures
.WithShape(new
{
user = new { id = 0, name = "" },
posts = new[] { new { id = 0, title = "" } }
})
निस्पंदन निस्पादन में त्रुटि:
// Simple error
.WithError(404)
// With custom message
.WithError(404, "User not found")
// With details
.WithError(422, "Validation failed", "Email address is invalid")
स्ट्रीमिंग:
// Enable streaming with token-by-token output
.WithStreaming()
.WithSseMode("LlmTokens")
// Stream complete objects
.WithStreaming()
.WithSseMode("CompleteObjects")
// Stream array items individually
.WithStreaming()
.WithSseMode("ArrayItems")
क़िस्म:
services.AddMockLlmHttpClient<IUserApiClient>(
baseApiPath: "/api/mock",
configure: handler => handler
.ForEndpoint("/users", config => config
.WithShape(new { id = 0, name = "", email = "" }))
);
नामित क्लाएंट:
services.AddMockLlmHttpClient(
name: "MockApi",
baseApiPath: "/api/mock",
configure: handler => handler
.ForEndpoint("/data", config => config
.WithShape(new { value = 0 }))
);
// Usage
var client = httpClientFactory.CreateClient("MockApi");
[Fact]
public async Task Should_Handle_User_Creation()
{
// Arrange
var client = HttpClientExtensions.CreateMockLlmClient(
"http://localhost:5116",
"/users",
config => config
.WithMethod("POST")
.WithShape(new { id = 0, name = "", email = "", createdAt = "" })
);
// Act
var newUser = new { name = "John Doe", email = "[email protected]" };
var response = await client.PostAsJsonAsync("/users", newUser);
// Assert
response.EnsureSuccessStatusCode();
var created = await response.Content.ReadFromJsonAsync<User>();
Assert.NotNull(created);
Assert.NotEqual(0, created.Id);
}
[Fact]
public async Task Should_Handle_Not_Found_Error()
{
// Arrange
var client = HttpClientExtensions.CreateMockLlmClient(
"http://localhost:5116",
"/users/999",
config => config.WithError(404, "User not found")
);
// Act
var response = await client.GetAsync("/users/999");
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
वह MockLlmHttpHandler है एक DelegatingHandler कि:
यह आपको वास्तविक उपयोग करने देता है HttpClient अपने अनुप्रयोग कोड को बदलने के बिना अपनी जांच में...
इस उपकरण के साथ अनेक परियोजनाओं पर काम करने के बाद, यहाँ उस पैटर्न हैं जो सबसे अच्छा काम करता है:
ministral-3:3b (3Bbms, 32के संदर्भ) - JSON के लिए खूनी! अत्यंत तेज, अति सही, न्यूनतम रैमllama3 (8Bbs, 8के संदर्भ) - उत्तम विशेषता और प्रदर्शन का सर्वोत्तम संतुलनmistral-nemo ( 12Bbs, 128के संदर्भ) - जटिल प्रसंग तथा विशाल डाटासेट्सgemma3:4b या phi3 - हल्का विकल्पफ्रन्टएण्ड विकास के लिए बैकेंड एपीआई के लिए इंतजार करने की जरूरत नहीं है. mostlylucid.mockllmapi आपको देता है:
इस और पारंपरिक उपहास के बीच अंतर? आपके सामने के कार्य यथार्थवादीता से किए गए, डाटा को एक दिन से जानता है. "यह ठट्ठा डाटा के साथ काम किया लेकिन वास्तविक डेटा के साथ असफल हो गया.
आप एक सरल ब्लॉग या एक जटिल विस्तार अनुप्रयोग निर्माण कर रहे हैं, आप इसे तेजी से, अधिक अच्छी तरह से परीक्षण, और विश्वास के साथ जहाज.
शुरू करने के लिए तैयार हैं?
docker compose up -d
यही कारण है कि यह है. कोई बैकेंड जरूरी नहीं है.
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.