+
404
+
+
Page not found :(
+
The requested page could not be found.
+
Python
+
+## Upload a document
+
+The following script performs the same operation, uploading a file:
+
+```python
+import requests
+
+files = {
+ "file1": ("README.md", open("README.md", "rb")),
+}
+
+data = {
+ "documentId": "doc01",
+}
+
+response = requests.post("http://127.0.0.1:9001/upload", files=files, data=data)
+
+print(response.text)
+```
+
+## Query
+
+```python
+import requests
+import json
+
+data = {"question": "Name one tool that I can use from command line"}
+
+response = requests.post(
+ "http://127.0.0.1:9001/ask",
+ headers={"Content-Type": "application/json"},
+ data=json.dumps(data),
+).json()
+
+if "text" in response:
+ print(response["text"])
+else:
+ print("Response does not contain a 'text' property.")
+```
+
+If you run the scripts, the output will look similar to:
+
+{: .console }
+> _You can use the "upload-file.sh", "ask.sh", and "search.sh" tools from the command line._
+
+# 
C#
+
+## Upload a document and answer questions
+
+Create a new .NET Console app and add package `Microsoft.KernelMemory.WebClient`, then add this code:
+
+```csharp
+using Microsoft.KernelMemory;
+
+var memory = new MemoryWebClient("http://127.0.0.1:9001/");
+
+await memory.ImportWebPageAsync(
+ "https://raw.githubusercontent.com/microsoft/kernel-memory/main/README.md",
+ documentId: "doc02");
+
+Console.WriteLine("Waiting for memory ingestion to complete...");
+while (!await memory.IsDocumentReadyAsync(documentId: "doc02"))
+{
+ await Task.Delay(TimeSpan.FromMilliseconds(1500));
+}
+
+var answer = await memory.AskAsync("Is there a Kernel Memory community and how can I join?");
+
+Console.WriteLine($"\nAnswer: {answer.Result}");
+```
+
+Run the application, and you should see:
+
+{: .console }
+> Answer: Yes, there is a Kernel Memory community. You can join the community by joining
+> the [Kernel Memory Discord server](https://aka.ms/KMdiscord).
+
+# Command line (bash, curl)
+
+## Upload a document
+
+Open a Bash console in the folder where you cloned Kernel Memory repository. The repository contains
+a **tools** folder with a few scripts, in particular `upload-file.sh` and `ask.sh` that you can use to send
+requests to the web service. You can also use `curl` if you prefer, the syntax is pretty simple, and the web service
+replies with JSON.
+
+Run the following commands:
+
+ cd tools
+ ./upload-file.sh -f README.md -i doc01 -s http://127.0.0.1:9001
+
+or:
+
+ curl -F 'file1=@"README.md"' -F 'documentId="doc01"' http://127.0.0.1:9001/upload
+
+You should see a confirmation message:
+
+{: .console }
+> ```json
+> {"index":"","documentId":"doc01","message":"Document upload completed, ingestion pipeline started"}
+> ```
+
+## Query
+
+ cd tools
+ ./ask.sh -q "Can I use KM from command line?" -s http://127.0.0.1:9001
+
+or:
+
+ curl -d'{"question":"Can I use KM from command line?"}' -H 'Content-Type: application/json' http://127.0.0.1:9001/ask
+
+The script will show the JSON returned by the web service, and among other details you should see the answer:
+
+{: .console }
+> _Yes, you can use Kernel Memory (KM) from the command line. There are several scripts provided, such
+as `upload-file.sh`,
+> `ask.sh`, and `search.sh`, that allow you to interact with KM from the command line. These scripts provide
+functionality
+> for uploading files, asking questions about your documents, and searching your indexed documents, respectively.
+> Additionally, there is a script called `run-qdrant.sh` that starts Qdrant, which is used to store and search vectors
+in KM._
+
+# 
Java
+
+## Upload a document
+
+Create a `FileUploadExample.java` file, with this code:
+
+```java
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+
+public class FileUploadExample {
+
+ public static void main(String[] args) throws IOException {
+ String url = "http://127.0.0.1:9001/upload";
+ String filename = "README.md";
+ String documentId = "doc01";
+
+ // Set up the file and form data
+ File file = new File(filename);
+ String boundary = "----WebKitFormBoundary" + Long.toHexString(System.currentTimeMillis());
+ String CRLF = "\r\n";
+ String charset = StandardCharsets.UTF_8.name();
+
+ // Create the HTTP connection
+ HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+ connection.setDoOutput(true);
+ connection.setRequestMethod("POST");
+ connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
+
+ // Write the request body
+ try (OutputStream output = connection.getOutputStream();
+ PrintWriter writer = new PrintWriter(new OutputStreamWriter(output, charset), true)) {
+ // Add file data
+ writer.append("--" + boundary).append(CRLF);
+ writer.append("Content-Disposition: form-data; name=\"file1\"; filename=\"" + file.getName() + "\"").append(CRLF);
+ writer.append("Content-Type: " + Files.probeContentType(file.toPath())).append(CRLF); // Use probeContentType
+ writer.append(CRLF).flush();
+ Files.copy(file.toPath(), output);
+ output.flush();
+ writer.append(CRLF).flush();
+
+ // Add form data
+ writer.append("--" + boundary).append(CRLF);
+ writer.append("Content-Disposition: form-data; name=\"documentId\"").append(CRLF);
+ writer.append(CRLF).append(documentId).append(CRLF).flush();
+
+ // End of request
+ writer.append("--" + boundary + "--").append(CRLF).flush();
+ }
+
+ // Get the response
+ try (InputStream responseStream = connection.getInputStream();
+ BufferedReader reader = new BufferedReader(new InputStreamReader(responseStream))) {
+ String line;
+ StringBuilder response = new StringBuilder();
+ while ((line = reader.readLine()) != null) {
+ response.append(line);
+ }
+ System.out.println(response.toString());
+ } finally {
+ connection.disconnect();
+ }
+ }
+}
+```
+
+Build and run the code:
+
+ javac FileUploadExample.java
+ java FileUploadExample
+
+and you should see the successful output:
+
+{: .console }
+> ```json
+> {"index":"","documentId":"doc01","message":"Document upload completed, ingestion pipeline started"}
+> ```
+
+## Query
+
+Create a `AskQuestionExample.java` file, with this code:
+
+```java
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+public class AskQuestionExample {
+
+ public static void main(String[] args) throws IOException {
+ String url = "http://127.0.0.1:9001/ask";
+ String jsonInputString = "{\"question\":\"Can I use KM from the command line?\"}";
+
+ // Create the HTTP connection
+ HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+ connection.setDoOutput(true);
+ connection.setRequestMethod("POST");
+ connection.setRequestProperty("Content-Type", "application/json");
+
+ // Write the request body
+ try (OutputStream os = connection.getOutputStream()) {
+ byte[] input = jsonInputString.getBytes("utf-8");
+ os.write(input, 0, input.length);
+ }
+
+ // Get the response
+ try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), "utf-8"))) {
+ StringBuilder response = new StringBuilder();
+ String responseLine;
+ while ((responseLine = br.readLine()) != null) {
+ response.append(responseLine.trim());
+ }
+ System.out.println(response.toString());
+ } finally {
+ connection.disconnect();
+ }
+ }
+}
+
+```
+
+Build and run the code:
+
+ javac AskQuestionExample.java
+ java AskQuestionExample
+
+and you should see the successful output:
+
+{: .console }
+> ```json
+> {"question":"Can I use KM from the command line?","noResult":false,"text":"Yes, you can use Kernel Memory (KM) from the command line. There are several scripts provided in the repository that allow you to interact with KM from the command line.\n\nThe `upload-file.sh` script is a client for command line uploads to Kernel Mem...
+> ```
+
+# More examples
+
+The repository contains more documentation and examples, here's some suggestions:
+
+* [KM concepts: Indexes, Documents, Tags and more](concepts)
+* [Memory API](functions)
+* [Collection of Jupyter notebooks with various scenarios](https://github.com/microsoft/kernel-memory/examples/000-notebooks)
+* [Using Kernel Memory web service to upload documents and answer questions](https://github.com/microsoft/kernel-memory/examples/001-dotnet-WebClient)
+* [Summarizing documents](https://github.com/microsoft/kernel-memory/examples/106-dotnet-retrieve-synthetics)
\ No newline at end of file
diff --git a/docs/run.cmd b/docs/run.cmd
new file mode 100755
index 000000000..42a8c0c18
--- /dev/null
+++ b/docs/run.cmd
@@ -0,0 +1 @@
+bundle exec jekyll serve --config _config.local.yml --baseurl="/kernel-memory" --host localhost --port 4000 --livereload
diff --git a/docs/security.md b/docs/security.md
new file mode 100644
index 000000000..825e59b65
--- /dev/null
+++ b/docs/security.md
@@ -0,0 +1,12 @@
+---
+nav_order: 16
+has_children: true
+title: Security
+permalink: /security
+layout: default
+---
+# Security
+
+{: .highlight }
+documentation under development
+
diff --git a/docs/SECURITY_FILTERS.md b/docs/security/security-filters.md
similarity index 99%
rename from docs/SECURITY_FILTERS.md
rename to docs/security/security-filters.md
index e0d7b16ae..2a057e80e 100644
--- a/docs/SECURITY_FILTERS.md
+++ b/docs/security/security-filters.md
@@ -1,3 +1,10 @@
+---
+nav_order: 1
+parent: Security
+title: Security Filters
+permalink: /security/filters
+layout: default
+---
# Security Filters
This document provides some guidance about how to organize your documents in
diff --git a/docs/security/service-api-keys.md b/docs/security/service-api-keys.md
new file mode 100644
index 000000000..50c5681b5
--- /dev/null
+++ b/docs/security/service-api-keys.md
@@ -0,0 +1,11 @@
+---
+nav_order: 4
+parent: Security
+title: Service API Keys
+permalink: /security/service-api-keys
+layout: default
+---
+# Service API keys
+
+{: .highlight }
+documentation under development
diff --git a/docs/serverless.md b/docs/serverless.md
new file mode 100644
index 000000000..5bb9a6d1d
--- /dev/null
+++ b/docs/serverless.md
@@ -0,0 +1,71 @@
+---
+nav_order: 15
+has_children: true
+title: Serverless (.NET)
+permalink: /serverless
+layout: default
+---
+# Serverless memory (.NET only)
+
+Kernel Memory works and scales at best when running as a service, allowing to
+ingest thousands of documents and information without blocking your app. However,
+you can also embed the `MemoryServerless` class in your app, using `KernelMemoryBuilder`.
+
+**`MemoryServerless` and `MemoryWebClient` implement the same interface
+and offer the same API**, so you can easily switch from one to the other.
+
+> {: .important }
+The embedded serverless mode is available only for .NET applications, by
+running the KM codebase inside the same process of your .NET application.
+
+> {: .warning }
+By default the serverless memory is **volatile** and keeps all data only in memory,
+without persistence on disk. Follow the configuration instructions to persist memory
+across multiple executions.
+
+
+
+
+
+> ### Importing documents into your Kernel Memory can be as simple as this:
+>
+> ```csharp
+> var memory = new KernelMemoryBuilder()
+> .WithOpenAIDefaults(Env.Var("OPENAI_API_KEY"))
+> .Build