@aj-archipelago/cortex 0.0.5 → 0.0.6

package/config.js

@@ -41,6 +41,11 @@ var config = convict({
         default: true,
         env: 'CORTEX_ENABLE_CACHE'
     },
+    enableGraphqlCache: {
+        format: Boolean,
+        default: false,
+        env: 'CORTEX_ENABLE_GRAPHQL_CACHE'
+    },
     defaultModelName: {
         format: String,
         default: null,

package/graphql/graphql.js

@@ -17,8 +17,7 @@ const subscriptions = require('./subscriptions');
 const { buildLimiters } = require('../lib/request');
 const { cancelRequestResolver } = require('./resolver');
 const { buildPathways, buildModels } = require('../config');
-
-const requestState = {}; // Stores the state of each request
+const { requestState } = require('./requestState');
 
 const getPlugins = (config) => {
     // server plugins
@@ -28,7 +27,7 @@ const getPlugins = (config) => {
 
     //if cache is enabled and Redis is available, use it
     let cache;
-    if (config.get('enableCache') && config.get('storageConnectionString')) {
+    if (config.get('enableGraphqlCache') && config.get('storageConnectionString')) {
         cache = new KeyvAdapter(new Keyv(config.get('storageConnectionString'),{
             ssl: true,
             abortConnect: false,            
@@ -72,7 +71,7 @@ const getTypedefs = (pathways) => {
     }
 
     type Subscription {
-        requestProgress(requestId: String!): RequestSubscription
+        requestProgress(requestIds: [String!]): RequestSubscription
     }
 `;
 

package/graphql/pathwayResolver.js

@@ -8,6 +8,7 @@ const { getFirstNToken, getLastNToken, getSemanticChunks } = require('./chunker'
 const { PathwayResponseParser } = require('./pathwayResponseParser');
 const { Prompt } = require('./prompt');
 const { getv, setv } = require('../lib/keyValueStorageClient');
+const { requestState } = require('./requestState');
 
 const MAX_PREVIOUS_RESULT_TOKEN_LENGTH = 1000;
 
@@ -17,9 +18,8 @@ const callPathway = async (config, pathwayName, requestState, { text, ...paramet
 }
 
 class PathwayResolver {
-    constructor({ config, pathway, requestState }) {
+    constructor({ config, pathway }) {
         this.config = config;
-        this.requestState = requestState;
         this.pathway = pathway;
         this.useInputChunking = pathway.useInputChunking;
         this.chunkMaxTokenLength = 0;
@@ -48,19 +48,71 @@ class PathwayResolver {
         this.pathwayPrompt = pathway.prompt;
     }
 
-    async resolve(args) {
-        if (args.async) {
-            // Asynchronously process the request
-            this.promptAndParse(args).then((data) => {
-                this.requestState[this.requestId].data = data;
-                pubsub.publish('REQUEST_PROGRESS', {
-                    requestProgress: {
-                        requestId: this.requestId,
-                        data: JSON.stringify(data)
+    async asyncResolve(args) {
+        // Wait with a sleep promise for the race condition to resolve
+        // const results = await Promise.all([this.promptAndParse(args), await new Promise(resolve => setTimeout(resolve, 250))]);
+        const data = await this.promptAndParse(args);
+        // Process the results for async
+        if(args.async || typeof data === 'string') { // if async flag set or processed async and got string response
+            const { completedCount, totalCount } = requestState[this.requestId];
+            requestState[this.requestId].data = data;
+            pubsub.publish('REQUEST_PROGRESS', {
+                requestProgress: {
+                    requestId: this.requestId,
+                    progress: completedCount / totalCount,
+                    data: JSON.stringify(data),
+                }
+            });
+        } else { //stream
+            for (const handle of data) {
+                handle.on('data', data => {
+                    console.log(data.toString());
+                    const lines = data.toString().split('\n').filter(line => line.trim() !== '');
+                    for (const line of lines) {
+                        const message = line.replace(/^data: /, '');
+                        if (message === '[DONE]') {
+                            // Send stream finished message
+                            pubsub.publish('REQUEST_PROGRESS', {
+                                requestProgress: {
+                                    requestId: this.requestId,
+                                    data: null,
+                                    progress: 1,
+                                }
+                            });
+                            return; // Stream finished
+                        }
+                        try {
+                            const parsed = JSON.parse(message);
+                            const result = this.pathwayPrompter.plugin.parseResponse(parsed)
+
+                            pubsub.publish('REQUEST_PROGRESS', {
+                                requestProgress: {
+                                    requestId: this.requestId,
+                                    data: JSON.stringify(result)
+                                }
+                            });
+                        } catch (error) {
+                            console.error('Could not JSON parse stream message', message, error);
+                        }
                     }
                 });
-            });
 
+                // data.on('end', () => {
+                //     console.log("stream done");
+                // });
+            }
+            
+        }
+    }
+
+    async resolve(args) {
+        if (args.async || args.stream) {
+            // Asyncronously process the request
+            // this.asyncResolve(args);
+            if (!requestState[this.requestId]) {
+                requestState[this.requestId] = {}
+            }
+            requestState[this.requestId] = { ...requestState[this.requestId], args, resolver: this.asyncResolve.bind(this) };
             return this.requestId;
         }
         else {
@@ -70,7 +122,6 @@ class PathwayResolver {
     }
 
     async promptAndParse(args) {
-
         // Get saved context from contextId or change contextId if needed
         const { contextId } = args;
         this.savedContextId = contextId ? contextId : null;
@@ -98,7 +149,7 @@ class PathwayResolver {
         if (this.pathway.inputChunkSize) {
             chunkMaxChunkTokenLength = Math.min(this.pathway.inputChunkSize, this.chunkMaxTokenLength);
         } else {
-             chunkMaxChunkTokenLength = this.chunkMaxTokenLength;
+            chunkMaxChunkTokenLength = this.chunkMaxTokenLength;
         }
         const encoded = encode(text);
         if (!this.useInputChunking || encoded.length <= chunkMaxChunkTokenLength) { // no chunking, return as is
@@ -124,7 +175,7 @@ class PathwayResolver {
 
     async summarizeIfEnabled({ text, ...parameters }) {
         if (this.pathway.useInputSummarization) {
-            return await callPathway(this.config, 'summary', this.requestState, { text, targetLength: 1000, ...parameters });
+            return await callPathway(this.config, 'summary', requestState, { text, targetLength: 1000, ...parameters });
         }
         return text;
     }
@@ -160,18 +211,25 @@ class PathwayResolver {
 
     // Process the request and return the result        
     async processRequest({ text, ...parameters }) {
-
         text = await this.summarizeIfEnabled({ text, ...parameters }); // summarize if flag enabled
         const chunks = this.processInputText(text);
 
         const anticipatedRequestCount = chunks.length * this.prompts.length;
 
-        if ((this.requestState[this.requestId] || {}).canceled) {
+        if ((requestState[this.requestId] || {}).canceled) {
             throw new Error('Request canceled');
         }
 
         // Store the request state
-        this.requestState[this.requestId] = { totalCount: anticipatedRequestCount, completedCount: 0 };
+        requestState[this.requestId] = { ...requestState[this.requestId], totalCount: anticipatedRequestCount, completedCount: 0 };
+
+        if (chunks.length > 1) { 
+            // stream behaves as async if there are multiple chunks
+            if (parameters.stream) {
+                parameters.async = true;
+                parameters.stream = false;
+            }
+        }
 
         // If pre information is needed, apply current prompt with previous prompt info, only parallelize current call
         if (this.pathway.useParallelChunkProcessing) {
@@ -189,17 +247,31 @@ class PathwayResolver {
             let result = '';
 
             for (let i = 0; i < this.prompts.length; i++) {
+                const currentParameters = { ...parameters, previousResult };
+
+                if (currentParameters.stream) { // stream special flow
+                    if (i < this.prompts.length - 1) { 
+                        currentParameters.stream = false; // if not the last prompt then don't stream
+                    }
+                    else {
+                        // use the stream parameter if not async
+                        currentParameters.stream = currentParameters.async ? false : currentParameters.stream;
+                    }
+                }
+
                 // If the prompt doesn't contain {{text}} then we can skip the chunking, and also give that token space to the previous result
                 if (!this.prompts[i].usesTextInput) {
                     // Limit context to it's N + text's characters
                     previousResult = this.truncate(previousResult, 2 * this.chunkMaxTokenLength);
-                    result = await this.applyPrompt(this.prompts[i], null, { ...parameters, previousResult });
+                    result = await this.applyPrompt(this.prompts[i], null, currentParameters);
                 } else {
                     // Limit context to N characters
                     previousResult = this.truncate(previousResult, this.chunkMaxTokenLength);
                     result = await Promise.all(chunks.map(chunk =>
-                        this.applyPrompt(this.prompts[i], chunk, { ...parameters, previousResult })));
-                    result = result.join("\n\n")
+                        this.applyPrompt(this.prompts[i], chunk, currentParameters)));
+                    if (!currentParameters.stream) {
+                        result = result.join("\n\n")
+                    }
                 }
 
                 // If this is any prompt other than the last, use the result as the previous context
@@ -225,20 +297,22 @@ class PathwayResolver {
     }
 
     async applyPrompt(prompt, text, parameters) {
-        if (this.requestState[this.requestId].canceled) {
+        if (requestState[this.requestId].canceled) {
             return;
         }
         const result = await this.pathwayPrompter.execute(text, { ...parameters, ...this.savedContext }, prompt);
-        this.requestState[this.requestId].completedCount++;
+        requestState[this.requestId].completedCount++;
 
-        const { completedCount, totalCount } = this.requestState[this.requestId];
+        const { completedCount, totalCount } = requestState[this.requestId];
 
-        pubsub.publish('REQUEST_PROGRESS', {
-            requestProgress: {
-                requestId: this.requestId,
-                progress: completedCount / totalCount,
-            }
-        });
+        if (completedCount < totalCount) {
+            pubsub.publish('REQUEST_PROGRESS', {
+                requestProgress: {
+                    requestId: this.requestId,
+                    progress: completedCount / totalCount,
+                }
+            });
+        }
 
         if (prompt.saveResultTo) {
             this.savedContext[prompt.saveResultTo] = result;

package/graphql/plugins/modelPlugin.js

@@ -1,7 +1,7 @@
 // ModelPlugin.js
 const handlebars = require('handlebars');
 const { request } = require("../../lib/request");
-const { getResponseResult } = require("../parser");
+const { encode } = require("gpt-3-encoder");
 
 const DEFAULT_MAX_TOKENS = 4096;
 const DEFAULT_PROMPT_TOKEN_RATIO = 0.5;
@@ -35,6 +35,7 @@ class ModelPlugin {
         }
 
         this.requestCount = 1;
+        this.shouldCache = config.get('enableCache') && (pathway.enableCache || pathway.temperature == 0);
     }
 
     getModelMaxTokenLength() {
@@ -102,6 +103,8 @@ class ModelPlugin {
         if (!choices || !choices.length) {
             if (Array.isArray(data) && data.length > 0 && data[0].translations) {
                 return data[0].translations[0].text.trim();
+            } else {
+                return data;
             }
         }
 
@@ -114,20 +117,43 @@ class ModelPlugin {
         const textResult = choices[0].text && choices[0].text.trim();
         const messageResult = choices[0].message && choices[0].message.content && choices[0].message.content.trim();
 
-        return messageResult || textResult || null;
+        return messageResult ?? textResult ?? null;
     }
 
+    logMessagePreview(messages) {
+        messages.forEach((message, index) => {
+            const words = message.content.split(" ");
+            const tokenCount = encode(message.content).length;
+            let preview;
+    
+            if (index === 0) {
+                preview = message.content;
+            } else {
+                preview = words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
+            }
+    
+            console.log(`Message ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"`);
+        });
+    }
+    
     async executeRequest(url, data, params, headers) {
-        const responseData = await request({ url, data, params, headers }, this.modelName);
+        const responseData = await request({ url, data, params, headers, cache: this.shouldCache }, this.modelName);
         const modelInput = data.prompt || (data.messages && data.messages[0].content) || data[0].Text || null;
-        console.log(`=== ${this.pathwayName}.${this.requestCount++} ===`)
-        console.log(`\x1b[36m${modelInput}\x1b[0m`)
+        
+        console.log(`=== ${this.pathwayName}.${this.requestCount++} ===`);
+        
+        if (data.messages && data.messages.length > 1) {
+            this.logMessagePreview(data.messages);
+        } else {
+            console.log(`\x1b[36m${modelInput}\x1b[0m`);
+        }
+        
         console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
-
+    
         if (responseData.error) {
             throw new Exception(`An error was returned from the server: ${JSON.stringify(responseData.error)}`);
         }
-
+    
         return this.parseResponse(responseData);
     }
 

package/graphql/plugins/openAiChatPlugin.js

@@ -14,9 +14,12 @@ class OpenAIChatPlugin extends ModelPlugin {
         const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
         const modelPromptMessages = this.getModelPromptMessages(modelPrompt, combinedParameters, text);
 
+        const { stream } = parameters;
+
         return {
             messages: modelPromptMessages || [{ "role": "user", "content": modelPromptText }],
             temperature: this.temperature ?? 0.7,
+            stream
         };
     }
 

package/graphql/plugins/openAiCompletionPlugin.js

@@ -30,6 +30,8 @@ class OpenAICompletionPlugin extends ModelPlugin {
         const modelPromptMessages = this.getModelPromptMessages(modelPrompt, combinedParameters, text);
         const modelPromptMessagesML = messagesToChatML(modelPromptMessages);
 
+        const { stream } = parameters;
+
         if (modelPromptMessagesML) {
         return {
             prompt: modelPromptMessagesML,
@@ -38,13 +40,15 @@ class OpenAICompletionPlugin extends ModelPlugin {
             top_p: 0.95,
             frequency_penalty: 0,
             presence_penalty: 0,
-            stop: ["<|im_end|>"]
+            stop: ["<|im_end|>"],
+            stream
         };
         } else {
         return {
             prompt: modelPromptText,
             max_tokens: this.getModelMaxTokenLength() - encode(modelPromptText).length - 1,
             temperature: this.temperature ?? 0.7,
+            stream
         };
         }
     }

package/graphql/requestState.js

@@ -0,0 +1,5 @@
+const requestState = {}; // Stores the state of each request
+
+module.exports = {
+    requestState
+};

package/graphql/resolver.js

@@ -5,10 +5,10 @@ const { PathwayResolver } = require("./pathwayResolver");
 // (parent, args, contextValue, info)
 const rootResolver = async (parent, args, contextValue, info) => {
     const { config, pathway, requestState } = contextValue;
-    const { temperature } = pathway;
+    const { temperature, enableGraphqlCache } = pathway;
 
-    // Turn off caching if temperature is 0
-    if (temperature == 0) {
+    // Turn on graphql caching if enableGraphqlCache true and temperature is 0
+    if (enableGraphqlCache && temperature == 0) { // || 
         info.cacheControl.setCacheHint({ maxAge: 60 * 60 * 24, scope: 'PUBLIC' });
     }
 

package/graphql/subscriptions.js

@@ -4,14 +4,27 @@
 
 const pubsub = require("./pubsub");
 const { withFilter } = require("graphql-subscriptions");
+const { requestState } = require("./requestState");
 
 const subscriptions = {
     requestProgress: {
         subscribe: withFilter(
-            () => pubsub.asyncIterator(['REQUEST_PROGRESS']),
+            (_, args, __, info) => {
+                const { requestIds } = args;
+                for (const requestId of requestIds) {
+                    if (!requestState[requestId]) {
+                        console.log(`requestProgress, requestId: ${requestId} not found`);
+                    } else {
+                        console.log(`starting async requestProgress, requestId: ${requestId}`);
+                        const { resolver, args } = requestState[requestId];
+                        resolver(args);
+                    }
+                }
+                return pubsub.asyncIterator(['REQUEST_PROGRESS'])
+            },
             (payload, variables) => {
                 return (
-                    payload.requestProgress.requestId === variables.requestId
+                    variables.requestIds.includes(payload.requestProgress.requestId)
                 );
             },
         ),

package/lib/request.js

@@ -1,20 +1,67 @@
-const axios = require('axios');
 const Bottleneck = require("bottleneck/es5");
+const RequestMonitor = require('./requestMonitor');
+const { config } = require('../config');
+let axios = require('axios');
+
+if (config.get('enableCache')) {
+    // Setup cache
+    const { setupCache } = require('axios-cache-interceptor');
+    axios = setupCache(axios, {
+        // enable cache for all requests by default
+        methods: ['get', 'post', 'put', 'delete', 'patch'],
+        interpretHeader: false,
+        ttl: 1000 * 60 * 60 * 24 * 7, // 7 days
+    }); 
+}
 
 const limiters = {};
+const monitors = {};
 
 const buildLimiters = (config) => {
     console.log('Building limiters...');
     for (const [name, model] of Object.entries(config.get('models'))) {
+        const rps = model.requestsPerSecond ?? 100;
         limiters[name] = new Bottleneck({
-            minTime: 1000 / (model.requestsPerSecond ?? 100),
-            // maxConcurrent: 20,
-        })
+            minTime: 1000 / rps,
+            maxConcurrent: rps,
+            reservoir: rps,      // Number of tokens available initially
+            reservoirRefreshAmount: rps,     // Number of tokens added per interval
+            reservoirRefreshInterval: 1000, // Interval in milliseconds
+        });
+        monitors[name] = new RequestMonitor();
+    }
+}
+
+setInterval(() => {
+    const monitorKeys = Object.keys(monitors);
+
+    // Skip logging if the monitors object does not exist or is empty
+    if (!monitorKeys || monitorKeys.length === 0) {
+      return;
     }
+
+    monitorKeys.forEach((monitorName) => {
+        const monitor = monitors[monitorName];
+        const callRate = monitor.getPeakCallRate();
+        const error429Rate = monitor.getError429Rate();
+        if (callRate > 0) {
+            console.log('------------------------');
+            console.log(`${monitorName} Call rate: ${callRate} calls/sec, 429 errors: ${error429Rate * 100}%`);
+            console.log('------------------------');
+            // Reset the rate monitor to start a new monitoring interval.
+            monitor.reset();
+        }
+    });
+  }, 10000); // Log rates every 10 seconds (10000 ms).
+
+const postWithMonitor = async (model, url, data, axiosConfigObj) => {
+    const monitor = monitors[model];
+    monitor.incrementCallCount();
+    return axios.post(url, data, axiosConfigObj);
 }
 
 const MAX_RETRY = 10;
-const postRequest = async ({ url, data, params, headers }, model) => {
+const postRequest = async ({ url, data, params, headers, cache }, model) => {
     let retry = 0;
     const errors = []
     for (let i = 0; i < MAX_RETRY; i++) {
@@ -22,13 +69,20 @@ const postRequest = async ({ url, data, params, headers }, model) => {
             if (i > 0) {
                 console.log(`Retrying request #retry ${i}: ${JSON.stringify(data)}...`);
                 await new Promise(r => setTimeout(r, 200 * Math.pow(2, i))); // exponential backoff
-            }
+            }           
             if (!limiters[model]) {
                 throw new Error(`No limiter for model ${model}!`);
             }
-            return await limiters[model].schedule(() => axios.post(url, data, { params, headers }));
+            const axiosConfigObj = { params, headers, cache };
+            if (params.stream || data.stream) {
+                axiosConfigObj.responseType = 'stream';
+            }           
+            return await limiters[model].schedule(() => postWithMonitor(model, url, data, axiosConfigObj));
         } catch (e) {
             console.error(`Failed request with data ${JSON.stringify(data)}: ${e}`);
+            if (e.response.status === 429) {
+                monitors[model].incrementError429Count();
+            }
             errors.push(e);
         }
     }
@@ -37,7 +91,10 @@ const postRequest = async ({ url, data, params, headers }, model) => {
 
 const request = async (params, model) => {
     const response = await postRequest(params, model);
-    const { error, data } = response;
+    const { error, data, cached } = response;
+    if (cached) {
+        console.info('/Request served with cached response.');
+    }
     if (error && error.length > 0) {
         const lastError = error[error.length - 1];
         return { error: lastError.toJSON() ?? lastError ?? error };

package/lib/requestMonitor.js

@@ -0,0 +1,43 @@
+class RequestMonitor {
+    constructor() {
+      this.callCount = 0;
+      this.peakCallRate = 0;
+      this.error429Count = 0;
+      this.startTime = new Date();
+    }
+  
+    incrementCallCount() {
+      this.callCount++;
+      if (this.getCallRate() > this.peakCallRate) {
+        this.peakCallRate = this.getCallRate();
+      }
+    }
+  
+    incrementError429Count() {
+      this.error429Count++;
+    }
+  
+    getCallRate() {
+      const currentTime = new Date();
+      const timeElapsed = (currentTime - this.startTime) / 1000; // time elapsed in seconds
+      return timeElapsed < 1 ? this.callCount : this.callCount / timeElapsed;
+    }
+
+    getPeakCallRate() {
+      return this.peakCallRate;
+    }
+  
+    getError429Rate() {
+      return this.error429Count / this.callCount;
+    }
+  
+    reset() {
+      this.callCount = 0;
+      this.error429Count = 0;
+      this.peakCallRate = 0;
+      this.startTime = new Date();
+    }
+  }
+  
+  module.exports = RequestMonitor;
+  

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "0.0.5",
-  "description": "Project Cortex",
+  "version": "0.0.6",
+  "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/aj-archipelago/cortex.git"
   },
   "keywords": [
     "cortex",
-    "ai"
+    "AI",
+    "prompt engineering",
+    "LLM",
+    "OpenAI",
+    "Azure",
+    "GPT-3",
+    "GPT-4",
+    "chatGPT",
+    "GraphQL"
   ],
   "main": "index.js",
   "scripts": {
@@ -22,11 +30,12 @@
     "@apollo/utils.keyvadapter": "^1.1.2",
     "@graphql-tools/schema": "^9.0.12",
     "@keyv/redis": "^2.5.4",
-    "apollo-server": "^3.11.1",
+    "apollo-server": "^3.12.0",
     "apollo-server-core": "^3.11.1",
     "apollo-server-express": "^3.11.1",
     "apollo-server-plugin-response-cache": "^3.8.1",
-    "axios": "^1.2.0",
+    "axios": "^1.3.4",
+    "axios-cache-interceptor": "^1.0.1",
     "bottleneck": "^2.19.5",
     "compromise": "^14.8.1",
     "compromise-paragraphs": "^0.1.0",

package/pathways/basePathway.js

@@ -1,4 +1,3 @@
-const { parseResponse } = require("../graphql/parser");
 const { rootResolver, resolver } = require("../graphql/resolver");
 const { typeDef } = require('../graphql/typeDef')
 
@@ -7,9 +6,9 @@ module.exports = {
     prompt: `{{text}}`,
     defaultInputParameters: {
         text: ``,
-        // Add the option of making every call async
-        async: false,
-        contextId : ``, // used to identify the context of the request
+        async: false, // switch to enable async mode
+        contextId: ``, // used to identify the context of the request,
+        stream: false, // switch to enable stream mode
     },
     inputParameters: {},
     typeDef,

package/pathways/bias.js

@@ -1,3 +1,4 @@
 module.exports = {
+    // enableCache: true,
     prompt: `{{text}}\n\nIs the above text written objectively?  Why or why not, explain with details:\n`
 }

package/pathways/translate.js

@@ -6,4 +6,5 @@ module.exports = {
     inputParameters: {
         to: `Arabic`,
     },
+    timeout: 300, // in seconds
 }

package/tests/chunking.test.js

@@ -4,6 +4,11 @@ jest.setTimeout(1800000);
 
 const testServer = getTestServer();
 
+//stop server after all tests
+afterAll(async () => {
+    await testServer.stop();
+});
+
 it('chunking test of translate endpoint with huge text', async () => {
     const response = await testServer.executeOperation({
         query: 'query translate($text: String!) { translate(text: $text) { result } }',

package/tests/main.test.js

@@ -14,6 +14,11 @@ const getTestServer = () => {
 
 const testServer = getTestServer();
 
+//stop server after all tests
+afterAll(async () => {
+    await testServer.stop();
+});
+
 it('validates bias endpoint', async () => {
     const response = await testServer.executeOperation({
         query: 'query bias($text: String!) { bias(text: $text) { result } }',

package/tests/translate.test.js

@@ -4,6 +4,11 @@ jest.setTimeout(1800000);
 
 const testServer = getTestServer();
 
+//stop server after all tests
+afterAll(async () => {
+    await testServer.stop();
+});
+
 it('test translate endpoint with huge arabic text english translation and check return non-arabic/english', async () => {
     const response = await testServer.executeOperation({
         query: 'query translate($text: String!, $to:String) { translate(text: $text, to:$to) { result } }',