Collection d'interfaces d'inversion de macromodèle en dialogue libre avec l'API

Connexion gratuite GPT3.5 à API

https://github.com/missuo/FreeGPT35

https://github.com/aurora-develop/aurora

https://github.com/Dalufishe/freegptjs

https://github.com/PawanOsman/ChatGPT

https://github.com/nashsu/FreeAskInternet

https://github.com/aurorax-neo/free-gpt3.5-2api

https://github.com/aurora-develop/free-gpt3.5-2api

https://github.com/LanQian528/chat2api

https://github.com/k0baya/FreeGPT35-Glitch

https://github.com/cliouo/FreeGPT35-Vercel

https://github.com/hominsu/freegpt35

https://github.com/xsigoking/chatgpt-free-api

https://github.com/skzhengkai/free-chatgpt-api

https://github.com/aurora-develop/aurora-glitch (en utilisant les ressources du glitch)

https://github.com/fatwang2/coze2openai (COZE à API, GPT4)

Modèle national inversé

recherche approfondie(DeepSeek) Interface avec l'API deepseek-free-api

Interface Moonshot AI (Kimi.ai) avec l'API kimi-free-api

étoiles sautantes (Leapfrog Ask StepChat) Interface avec l'API step-free-api

Ali Tongyi (Qwen) Interface avec l'API qwen-free-api

ZhipuAI (un discours intellectuellement stimulant) Interface avec l'API glm-free-api

Meta AI (metaso) Interface avec l'API metaso-free-api

Saut d'octet (Beanbag) Interface avec l'API doubao-free-api

Saut d'octet (c'est-à-dire Dream AI) Interface avec l'API jimeng-free-api

Interface Spark vers API spark-free-api

Interface MiniMax (Conch AI) avec l'API hailuo-free-api

Interface Emohaa vers API emohaa-free-api

Programme sans login avec interface de chat

https://github.com/Mylinde/FreeGPT

Le code de travail pour cloudflare, attachez votre propre nom de domaine pour jouer :

addEventListener("fetch", event => {
event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
// S'assurer que la requête est une requête POST et que le chemin d'accès est correct
if (request.method === "POST" && new URL(request.url).pathname === "/v1/chat/completions") {
const url = 'https://multillm.ai-pro.org/api/openai-completion' ; // adresse de l'API cible
const headers = new Headers(request.headers) ;

// Ajouter ou modifier les en-têtes si nécessaire
headers.set('Content-Type', 'application/json') ;

// Récupère le corps de la requête et analyse le JSON
const requestBody = await request.json() ;
const stream = requestBody.stream ; // obtenir l'argument stream

// Construire une nouvelle demande
const newRequest = new Request(url, {
méthode : "POST",
en-têtes : en-têtes,
body : JSON.stringify(requestBody) // utilise le corps modifié
});

try {
// Envoi d'une requête à l'API cible
const response = await fetch(newRequest) ;

// Déterminer le type de réponse en fonction du paramètre "stream" (flux)
if (stream) {
// Gestion des réponses en continu
const { readable, writable } = new TransformStream() ;
response.body.pipeTo(writable) ;
return new Response(readable, {
headers : response.headers
});
} else {
// Réponse de retour normale
return new Response(response.body, {
status : response.status,
headers : response.headers
});
}
} catch (e) {
// Si la demande échoue, renvoyer un message d'erreur
return new Response(JSON.stringify({ error : 'Unable to reach the backend API' }), { status : 502 }) ;
}
} else {
// Renvoie une erreur si la méthode de requête n'est pas POST ou si le chemin d'accès est incorrect.
return new Response('Not found', { status : 404 }) ;
}
}

Exemple POST :

curl --location "https://ai-pro-free.aivvm.com/v1/chat/completions" \N- en anglais
--header 'Content-Type : application/json' \N--Content-Type : application/json' \N--Content-Type : application/json
--data '{
"modèle" : "gpt-4-turbo".
"messages" : [
{
"role" : "user", "content" : "Why Lu Xun Beat Zhou Shuren"
}],
"stream" : vrai
}'

Ajouter un code de pseudo-streaming (la sortie sera plus lente) :

addEventListener("fetch", event => {
event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
if (request.method === "OPTIONS") {
return new Response(null, {
headers : {
'Access-Control-Allow-Origin' : '*',
"Access-Control-Allow-Headers" : '*'
}, status : 204
})
}
// S'assurer que la requête est une requête POST et que le chemin d'accès est correct
if (request.method === "POST" && new URL(request.url).pathname === "/v1/chat/completions") {
const url = 'https://multillm.ai-pro.org/api/openai-completion' ; // adresse de l'API cible
const headers = new Headers(request.headers) ;

// Ajouter ou modifier les en-têtes si nécessaire
headers.set('Content-Type', 'application/json') ;

// Récupère le corps de la requête et analyse le JSON
const requestBody = await request.json() ;
const stream = requestBody.stream ; // obtenir l'argument stream

// Construire une nouvelle demande
const newRequest = new Request(url, {
méthode : "POST",
en-têtes : en-têtes,
body : JSON.stringify(requestBody) // utilise le corps modifié
});

try {
// Envoi d'une requête à l'API cible
const response = await fetch(newRequest) ;

// Déterminer le type de réponse en fonction du paramètre "stream" (flux)
if (stream) {
const originalJson = await response.json() ; // lire les données complètes en une seule fois
// Créer un flux lisible
const readableStream = new ReadableStream({
start(controller) {
// Envoi des données de départ
const startData = createDataChunk(originalJson, "start") ;
controller.enqueue(new TextEncoder().encode('data : ' + JSON.stringify(startData) + '\n\n')) ;

// En supposant que plusieurs morceaux de données soient traités et envoyés conformément à originalJson.
// Par exemple, pour simuler l'envoi de données par lots
const content = originalJson.choices[0].message.content ; // suppose qu'il s'agit du contenu à envoyer
const newData = createDataChunk(originalJson, "data", content) ;
controller.enqueue(new TextEncoder().encode('data : ' + JSON.stringify(newData) + '\n\n')) ;

// Envoi des données finales
const endData = createDataChunk(originalJson, "end") ;
controller.enqueue(new TextEncoder().encode('data : ' + JSON.stringify(endData) + '\n\n')) ;

controller.enqueue(new TextEncoder().encode('data : [DONE]')) ;
// Marque la fin du flux
controller.close() ;
}
});
return new Response(readableStream, {
headers : {
'Access-Control-Allow-Origin' : '*',
"Access-Control-Allow-Headers" : '*',
Content-Type" : "text/event-stream",
Cache-Control" : "no-cache",
Connexion" : "keep-alive
}
});
} else {
// Réponse de retour normale
return new Response(response.body, {
status : response.status,
headers : response.headers
});
}
} catch (e) {
// Si la demande échoue, renvoyer un message d'erreur
return new Response(JSON.stringify({ error : 'Unable to reach the backend API' }), { status : 502 }) ;
}
} else {
// Renvoie une erreur si la méthode de requête n'est pas POST ou si le chemin d'accès est incorrect.
return new Response('Not found', { status : 404 }) ;
}
}

// Créer des blocs de données différents en fonction du type
function createDataChunk(json, type, content = {}) {
switch (type) {
cas "start".
return {
id : json.id,
objet : "chat.completion.chunk",
created : json.created,
modèle : json.model,
choices : [{ delta : {}, index : 0, finish_reason : null }]} ; }
cas "data".
return {
id : json.id,
objet : "chat.completion.chunk",
created : json.created,
modèle : json.model,
choices : [{ delta : { content }, index : 0, finish_reason : null }]} ; }
cas "end".
return {
id : json.id,
objet : "chat.completion.chunk",
created : json.created,
modèle : json.model,
choices : [{ delta : {}, index : 0, finish_reason : 'stop' }]} ; }
par défaut.
return {} ;
}
}