Because the communication protocol for server-chatbot communication hadn't been decided entirely, it hasn't been implemented correctly in the ClusterClient message models.
Now the protocol is kind of clear and will be implemented as described on the wiki.

        /// <summary>
        /// Logica: krijgt MatchedQuestionsModel binnen
        /// en beslist of er een goede match is + het antwoord op deze vraag
        /// 
        /// </summary>
        /// <param name="matchQuestionModels"></param>
        /// <returns>
        /// 
        /// Resultaat bij Bernd is dan
        /// 1) Er is een goede match
        /// 2) We moeten verderZoeken
        /// 3) Er is geen match en vragen zijn op
        /// 
        /// Ik laat aan jullie om te beslissen hoe dit 1 model / meerdere modellen eruit zullen zien
        /// return model; aan het functie is het enige dat ik nodig heb :)
        /// 
        /// </returns>
        public static Object ProcessNLPMatchQuestionsResponse(List<MatchQuestionModelResponse> matchQuestionModels)
        {

            return null;
        }

As you can see above, the ProcessNLPMatchQuestionsResponse gets a list of MatchQuestionModelResponses as input. Given the definition of the MatchQuestionModelResponse:

    [Serializable]
    public class MatchQuestionModelResponse : BaseModel
    {
        private int _question_id = -1;
        private MatchQuestionModelInfo[] _possible_matches = null;
        private int _msg_id = -1;

        public int question_id { get => _question_id; set => _question_id = value; }
        public MatchQuestionModelInfo[] possible_matches { get => _possible_matches; set => _possible_matches = value; }
        public int msg_id { get => _msg_id; set => _msg_id = value; }

        public bool IsComplete()
        {
            return possible_matches != null && _question_id != -1 && _msg_id != -1;
        }
    }

shouldn't the task of ProcessNLPMatchQuestionsResponse just be to check ONE MatchQuestionModelResponse for a match in its MatchQuestionModelInfos instead of checking a list of MatchQuestionModelResponses? So basically:

        public static Object ProcessNLPMatchQuestionsResponse(MatchQuestionModelResponse matchQuestionModel)
        {

            return null;
        }

The server may respond with XML whenever the client accepts this, so the client should specifically ask for json.

Try to implement an algorithm that checks whether two questions are the same.

Basic API using GET/POST to get tasks from the Cluster Connector server and post the processing results of the NLP model.

https://programminghistorian.org/en/lessons/creating-apis-with-python-and-flask

Follow Tutorial from Real Python .

similar to #44

Handle what to do with received offensive models.

1. Create logic models for (plain C# won't be send as JSON.. yet?)

• Representing a sentence that is offensive
• Representing a sentence that is non-offensive

2. Discuss with chatbot and moderator what to do with both offensive and non-offensive sentences.
   Moderator, manual review along with the user-id for example?
   Chatbot, notification to user with warning?

Look for an existing model or train a new one to distinguish meaningful sentences from gibberish.

Whenever you are wondering to which component some (new) feature/functionality should belong, you can follow these rules of thumb and start a discussion below in case of uncertainties:

The feature

• implements a decision making process -> logic
• implements (part of) the communication protocol between the server and modules/servicies (chatbot, NLP ...):
  • Server side -> cluster connector, cluster api
  • Client side in Python -> cluster-connector (a.k.a Python connector, Python api)
  • Client side in C# -> ClusterClient (a.k.a C# connector)
• implements part of the dialog with a user -> chatbot
• provides some 'intelligent' functionality to analyse user input -> NLP tools
• ...

function: question2features
function: features2probabilityAbuse

SendQuestion() currently throws a TimeoutException when no response was received from the server before a timeout occurred. However, as this is an async method, the exception cannot be catched by its caller. Therefore it's easiest at the moment to simply return null.

The ClusterClient module currently expects the server to push questions that should be answered, i.e. it should send them whenever available. However, as in the last meeting it appeared to be more clear for the logic to handle this situation using a plain old request-response flow.
The way ClusterClient works now is described in this figure:

The way a request-response flow works as proposed is shown here:

Some extra notes:

• In the first scenario the server can decide to wait for a bunch of questions to bundle them and send them all at once. Then only for every group of, say X, questions, a message should be sent in one way. If the buffer set in ClusterClient happens to be empty when a user wants to answer questions, it can still send a request to the server. ClusterClient could decide itself whether an extra request is needed, because it knows when it has requested last, so it can set a reasonable timeout between two 'hard' requests to give the server some time. Also it could keep track of the unanswered questions asked by users (which it already does, but those questions can still be answered by the NLP at that time), so it basically knows already whether there's any chance the server will ever send unanswered questions. However when the server sends an 'sorry, have to ask forum', ClusterClient will consider this to be the answer, unless this type of answer could be distinguished from real answers.
• In the second scenario 2 messages are sent over the websocket connection for every user who wants to answer a question. This seems less efficient to me then the first scenario, though more comprehensible, perhaps.

Simple HTTP requests are easy. Speeding up using the header connection: keep-alive (using Sessions in Python requests) is easy too. However, this way we're still bound to using HTTP, in which the server can't push a message to the client. That's why it might be worth the effort of experimenting with web sockets, both in Python and in Azure.

See proposal in response to issue #42.

So if a user sends a question that currently can't be answered and isn't similar to any other open question, and therefore the question gets posted to the forum (added to open questions in the DB), how should the server respond to the chatbot?

being worked on
Fill out ClusterLogic > NLPHandler > ProcessNLPResponse

Response meaning, the Server receives the 'Response' of the NLP tool.

Example:

public static Object ProcessNLPMatchQuestionsResponse(List<MatchQuestionModelResponse> matchQuestionModels)
        {
            return null;
        }

With MatchQuestionModelResponse being:

    [Serializable]
    public class MatchQuestionModelResponse : BaseModel
    {
        private int _question_id = -1;
        private MatchQuestionModelInfo[] _possible_matches = null;
        private int _msg_id = -1;

        public int question_id { get => _question_id; set => _question_id = value; }
        public MatchQuestionModelInfo[] possible_matches { get => _possible_matches; set => _possible_matches = value; }
        public int msg_id { get => _msg_id; set => _msg_id = value; }

        public bool IsComplete()
        {
            return possible_matches != null && _question_id != -1 && _msg_id != -1;
        }
    }

    [Serializable]
    public class MatchQuestionModelInfo : BaseModel
    {
        
        private int _question_id = -1;
        private float _prob = -1;

        public int question_id { get => _question_id; set => _question_id = value; }
        public float prob { get => _prob; set => _prob = value; }

        public bool IsComplete()
        {
            return _question_id != -1 && prob != -1;
        }
    }

A C# representation of the NLP response returning possible related and matching questions

'matchQuestionModels' is a list containing all models the server has received. Please process these models based on their data. Example:
The above represents a model in which the server receives a list of questions and probabilities to represent similarity with a given question. The logic SHOULD decide which question can be used as a similar question to the given one.

TODO:

1. prepare and return a model representing that either:

• Represents a similar question to the given one
• Represent a model in which no matching question could be found

2. what to do with this model (decide on paper first)
   --> Discuss with chatbot and Forum, questions without similarities will probably be send to the forum. Questions with similarities will probably be processed by the server and answers to the highest matching question will be send to the chatbot to be send to the user.

Combine the LUIS model, the QnA-maker and the "forum" (will still be a loose end)

Python script to apply models to q&a databases.
returns answers as .json objects.

The NLP tools now have a functionality to analyse a text string for being nonsense. See this wiki page for a proposal on the communication protocol.

Create a simple database with some contacts for (imaginary) people

Currently connections to the Cluster API server can (and should) be done over HTTPS (SSL), which is encrypts the information sent over the connection. However, there's is no need to authenticate to use the API, so no matter the strength of SSL encryption, we currently don't control who is using the API. Proposed solutions contain:

• extending the message protocol to use a hash of the message and some secret, which is known by the client (NLP/chatbot) and server only
• using some kind of RSA signing (in which case the server would keep a list of trusted public keys)
• only allowing msg_ids that are expected (i.e. which have been generated by the server and not yet sent by the client)
• HTTP header authentication
• ...

By using the HTTP header connection: keep-alive one can use the persistency of the HTTP/1.1 protocol instead of creating seperate connections for each GET/POST request. Example for requests in Python: see StackOverflow.

The server expects an Authorization header field, which is currently not sent along with the initiall HTTP request when setting up the websocket connection.

get_next_request() currently doesn't ask the server for new tasks when there are still tasks in the task list (hidden variable). A possibility to improve the efficiency of get_next_request() is to return a pending task when it is immediately available in the task list and ask the server for tasks in a seperate thread.

Development of user interface for interaction with moderator functionality using 'Figma' tool.

The NLP tools need to retrieve a blacklist containing offensive words from the server. This list changes over time, so it cannot store the list permanently.
A few possiblities are the following:

• the server sends the list along with match questions request every time
• the NLP connector sends a request to the server to check whether it has the most up to date blacklist and if it doesn't, the server sends the blacklist
• the server keeps a hash of the date when the blacklist was updated for the last time and sends this hash along with every match questions request. The NLP connector saves this hash and compares it with every request. When the stored hash differs from the one sent by the server, the NLP connector sends a request to the server asking for the updated blacklist and caches the response along with the newest hash. Instead of a hash, the date itself could be used or just an incremented number of course.

A function that turns a question into features and a function that calculates the probability that 2 feature sets are equal.