xref: /plugin/aichat/helper.php (revision 7be8078ef9026e317a5c01f90a94183276bbbbd2) 
1<?php
2
3use dokuwiki\Extension\CLIPlugin;
4use dokuwiki\Extension\Plugin;
5use dokuwiki\plugin\aichat\AIChat;
6use dokuwiki\plugin\aichat\Chunk;
7use dokuwiki\plugin\aichat\Embeddings;
8use dokuwiki\plugin\aichat\Model\ChatInterface;
9use dokuwiki\plugin\aichat\Model\EmbeddingInterface;
10use dokuwiki\plugin\aichat\ModelFactory;
11use dokuwiki\plugin\aichat\Storage\AbstractStorage;
12
13/**
14 * DokuWiki Plugin aichat (Helper Component)
15 *
16 * @license GPL 2 http://www.gnu.org/licenses/gpl-2.0.html
17 * @author  Andreas Gohr <gohr@cosmocode.de>
18 */
19class helper_plugin_aichat extends Plugin
20{
21    /** @var ModelFactory */
22    public $factory;
23
24    /** @var CLIPlugin $logger */
25    protected $logger;
26
27    /** @var Embeddings */
28    protected $embeddings;
29    /** @var AbstractStorage */
30    protected $storage;
31
32    /** @var array where to store meta data on the last run */
33    protected $runDataFile;
34
35
36    /**
37     * Constructor. Initializes vendor autoloader
38     */
39    public function __construct()
40    {
41        require_once __DIR__ . '/vendor/autoload.php'; // FIXME obsolete from Kaos onwards
42        global $conf;
43        $this->runDataFile = $conf['metadir'] . '/aichat__run.json';
44        $this->loadConfig();
45        $this->factory = new ModelFactory($this->conf);
46    }
47
48    /**
49     * Use the given CLI plugin for logging
50     *
51     * @param CLIPlugin $logger
52     * @return void
53     */
54    public function setLogger($logger)
55    {
56        $this->logger = $logger;
57    }
58
59    /**
60     * Update the configuration
61     *
62     * @param array $config
63     * @return void
64     */
65    public function updateConfig(array $config)
66    {
67        $this->conf = array_merge($this->conf, $config);
68        $this->factory->updateConfig($config);
69    }
70
71    /**
72     * Check if the current user is allowed to use the plugin (if it has been restricted)
73     *
74     * @return bool
75     */
76    public function userMayAccess()
77    {
78        global $auth;
79        global $USERINFO;
80        global $INPUT;
81
82        if (!$auth) return true;
83        if (!$this->getConf('restrict')) return true;
84        if (!isset($USERINFO)) return false;
85
86        return auth_isMember($this->getConf('restrict'), $INPUT->server->str('REMOTE_USER'), $USERINFO['grps']);
87    }
88
89    /**
90     * Access the Chat Model
91     *
92     * @return ChatInterface
93     */
94    public function getChatModel()
95    {
96        return $this->factory->getChatModel();
97    }
98
99    /**
100     * @return ChatInterface
101     */
102    public function getRephraseModel()
103    {
104        return $this->factory->getRephraseModel();
105    }
106
107    /**
108     * Access the Embedding Model
109     *
110     * @return EmbeddingInterface
111     */
112    public function getEmbeddingModel()
113    {
114        return $this->factory->getEmbeddingModel();
115    }
116
117    /**
118     * Access the Embeddings interface
119     *
120     * @return Embeddings
121     */
122    public function getEmbeddings()
123    {
124        if ($this->embeddings instanceof Embeddings) {
125            return $this->embeddings;
126        }
127
128        $this->embeddings = new Embeddings(
129            $this->getChatModel(),
130            $this->getEmbeddingModel(),
131            $this->getStorage(),
132            $this->conf
133        );
134        if ($this->logger) {
135            $this->embeddings->setLogger($this->logger);
136        }
137
138        return $this->embeddings;
139    }
140
141    /**
142     * Access the Storage interface
143     *
144     * @return AbstractStorage
145     */
146    public function getStorage()
147    {
148        if ($this->storage instanceof AbstractStorage) {
149            return $this->storage;
150        }
151
152        $class = '\\dokuwiki\\plugin\\aichat\\Storage\\' . $this->getConf('storage') . 'Storage';
153        $this->storage = new $class($this->conf);
154
155        if ($this->logger) {
156            $this->storage->setLogger($this->logger);
157        }
158
159        return $this->storage;
160    }
161
162    /**
163     * Ask a question with a chat history
164     *
165     * @param string $question
166     * @param array[] $history The chat history [[user, ai], [user, ai], ...]
167     * @return array ['question' => $question, 'answer' => $answer, 'sources' => $sources]
168     * @throws Exception
169     */
170    public function askChatQuestion($question, $history = [], $sourcePage = '')
171    {
172        if ($history && $this->getConf('rephraseHistory') > 0) {
173            $contextQuestion = $this->rephraseChatQuestion($question, $history);
174
175            // Only use the rephrased question if it has more history than the chat history provides
176            if ($this->getConf('rephraseHistory') > $this->getConf('chatHistory')) {
177                $question = $contextQuestion;
178            }
179        } else {
180            $contextQuestion = $question;
181        }
182        return $this->askQuestion($question, $history, $contextQuestion, $sourcePage);
183    }
184
185    /**
186     * Ask a single standalone question
187     *
188     * @param string $question The question to ask
189     * @param array $history [user, ai] of the previous question
190     * @param string $contextQuestion The question to use for context search
191     * @param string $sourcePage The page the question was asked on
192     * @return array ['question' => $question, 'answer' => $answer, 'sources' => $sources]
193     * @throws Exception
194     */
195    public function askQuestion($question, $history = [], $contextQuestion = '', $sourcePage = '')
196    {
197        if($sourcePage) {
198            $similar = $this->getEmbeddings()->getPageChunks($sourcePage);
199        } else {
200            $similar = $this->getEmbeddings()->getSimilarChunks($contextQuestion ?: $question, $this->getLanguageLimit());
201        }
202
203        if ($similar) {
204            $context = implode(
205                "\n",
206                array_map(static fn(Chunk $chunk) => "\n```\n" . $chunk->getText() . "\n```\n", $similar)
207            );
208            $prompt = $this->getPrompt('question', [
209                'context' => $context,
210                'question' => $question,
211                'customprompt' => $this->getConf('customprompt'),
212            ]);
213        } else {
214            $prompt = $this->getPrompt('noanswer', [
215                'question' => $question,
216            ]);
217            $history = [];
218        }
219
220        $messages = $this->prepareMessages(
221            $this->getChatModel(),
222            $prompt,
223            $history,
224            $this->getConf('chatHistory')
225        );
226        $answer = $this->getChatModel()->getAnswer($messages);
227
228        return [
229            'question' => $question,
230            'contextQuestion' => $contextQuestion,
231            'answer' => $answer,
232            'sources' => $similar,
233        ];
234    }
235
236    /**
237     * Rephrase a question into a standalone question based on the chat history
238     *
239     * @param string $question The original user question
240     * @param array[] $history The chat history [[user, ai], [user, ai], ...]
241     * @return string The rephrased question
242     * @throws Exception
243     */
244    public function rephraseChatQuestion($question, $history)
245    {
246        $prompt = $this->getPrompt('rephrase', [
247            'question' => $question,
248        ]);
249        $messages = $this->prepareMessages(
250            $this->getRephraseModel(),
251            $prompt,
252            $history,
253            $this->getConf('rephraseHistory')
254        );
255        return $this->getRephraseModel()->getAnswer($messages);
256    }
257
258    /**
259     * Prepare the messages for the AI
260     *
261     * @param ChatInterface $model The used model
262     * @param string $promptedQuestion The user question embedded in a prompt
263     * @param array[] $history The chat history [[user, ai], [user, ai], ...]
264     * @param int $historySize The maximum number of messages to use from the history
265     * @return array An OpenAI compatible array of messages
266     */
267    protected function prepareMessages(
268        ChatInterface $model,
269        string $promptedQuestion,
270        array $history,
271        int $historySize
272    ): array {
273        // calculate the space for context
274        $remainingContext = $model->getMaxInputTokenLength(); // might be 0
275        $remainingContext -= $this->countTokens($promptedQuestion);
276        $safetyMargin = abs($remainingContext) * 0.05; // 5% safety margin
277        $remainingContext -= $safetyMargin; // may be negative, it will be ignored then
278
279        $messages = $this->historyMessages($history, $remainingContext, $historySize);
280        $messages[] = [
281            'role' => 'user',
282            'content' => $promptedQuestion
283        ];
284        return $messages;
285    }
286
287    /**
288     * Create an array of OpenAI compatible messages from the given history
289     *
290     * Only as many messages are used as fit into the token limit
291     *
292     * @param array[] $history The chat history [[user, ai], [user, ai], ...]
293     * @param int $tokenLimit The maximum number of tokens to use, negative limit disables this check
294     * @param int $sizeLimit The maximum number of messages to use
295     * @return array
296     */
297    protected function historyMessages(array $history, int $tokenLimit, int $sizeLimit): array
298    {
299        $remainingContext = $tokenLimit;
300
301        $messages = [];
302        $history = array_reverse($history);
303        $history = array_slice($history, 0, $sizeLimit);
304        foreach ($history as $row) {
305            $length = $this->countTokens($row[0] . $row[1]);
306
307            if ($tokenLimit > 0 && $length > $remainingContext) {
308                break;
309            }
310            $remainingContext -= $length;
311
312            $messages[] = [
313                'role' => 'assistant',
314                'content' => $row[1]
315            ];
316            $messages[] = [
317                'role' => 'user',
318                'content' => $row[0]
319            ];
320        }
321        return array_reverse($messages);
322    }
323
324    /**
325     * Get an aproximation of the token count for the given text
326     *
327     * @param $text
328     * @return int
329     */
330    protected function countTokens($text)
331    {
332        return count($this->getEmbeddings()->getTokenEncoder()->encode($text));
333    }
334
335    /**
336     * Load the given prompt template and fill in the variables
337     *
338     * @param string $type
339     * @param string[] $vars
340     * @return string
341     */
342    protected function getPrompt($type, $vars = [])
343    {
344        $template = file_get_contents($this->localFN($type, 'prompt'));
345        $vars['language'] = $this->getLanguagePrompt();
346
347        $replace = [];
348        foreach ($vars as $key => $val) {
349            $replace['{{' . strtoupper($key) . '}}'] = $val;
350        }
351
352        return strtr($template, $replace);
353    }
354
355    /**
356     * Construct the prompt to define the answer language
357     *
358     * @return string
359     */
360    protected function getLanguagePrompt()
361    {
362        global $conf;
363        $isoLangnames = include(__DIR__ . '/lang/languages.php');
364
365        $currentLang = $isoLangnames[$conf['lang']] ?? 'English';
366
367        if ($this->getConf('preferUIlanguage') > AIChat::LANG_AUTO_ALL) {
368            if (isset($isoLangnames[$conf['lang']])) {
369                $languagePrompt = 'Always answer in ' . $isoLangnames[$conf['lang']] . '.';
370                return $languagePrompt;
371            }
372        }
373
374        $languagePrompt = 'Always answer in the user\'s language. ' .
375            "If you are unsure about the language, speak $currentLang.";
376        return $languagePrompt;
377    }
378
379    /**
380     * Should sources be limited to current language?
381     *
382     * @return string The current language code or empty string
383     */
384    public function getLanguageLimit()
385    {
386        if ($this->getConf('preferUIlanguage') >= AIChat::LANG_UI_LIMITED) {
387            global $conf;
388            return $conf['lang'];
389        } else {
390            return '';
391        }
392    }
393
394    /**
395     * Store info about the last run
396     *
397     * @param array $data
398     * @return void
399     */
400    public function setRunData(array $data)
401    {
402        file_put_contents($this->runDataFile, json_encode($data, JSON_PRETTY_PRINT));
403    }
404
405    /**
406     * Get info about the last run
407     *
408     * @return array
409     */
410    public function getRunData()
411    {
412        if (!file_exists($this->runDataFile)) {
413            return [];
414        }
415        return json_decode(file_get_contents($this->runDataFile), true);
416    }
417}
418