Cognee 1.6.7

In the AWS Marketplace listing, choose Continue to Subscribe, then Continue to Configuration. Pick Cognee 1.6.7 on Ubuntu 24.04 as the software version and select your Region. Then choose Launch through EC2, and select m5.xlarge, your key pair and a security group as described above.

Or launch with the AWS CLI. Replace the values in angle brackets:

aws ec2 run-instances --region <region> --image-id <ami-id-from-the-listing> \
  --instance-type m5.xlarge --key-name <your-key-pair> \
  --security-group-ids <your-security-group> --subnet-id <your-subnet> \
  --metadata-options HttpTokens=required,HttpEndpoint=enabled \
  --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=cognee}]'

First boot takes a few minutes. It generates the instance's secrets and certificate, proves the access controls and then opens nginx.

The bundled model then loads in the background. On a new instance this can take up to about ten minutes, because EBS restores the volume from its snapshot as it is first read. sudo systemctl is-active ollama prints active once the model is in memory.

Connect over SSH as the ubuntu user, which is the SSH user for Cognee 1.6.7 on Ubuntu 24.04:

ssh -i <your-key.pem> ubuntu@<public-ip>

Check the service itself, not just the unit state. First list the service states, then query Cognee's health endpoint through nginx on HTTPS:

systemctl is-active cognee-egress-guard cognee-firstboot ollama ollama-proxy.socket cognee cognee-ui nginx
C=$(curl -sk -o /dev/null -w '%{http_code}' https://127.0.0.1/health)
echo "GET /health -> HTTP $C" [ "$C" = 200 ] && echo COGNEE_OK

active active active active active active active GET /health -> HTTP 200 COGNEE_OK

Port 80 redirects to HTTPS. The API, the web interface and the model server answer on loopback only, and only for the service accounts that need them. Any other user on the instance is refused, and nothing but 22, 80 and 443 listens on the network:

H=$(sudo sed -n 's#^COGNEE_URL=https://\([^/]*\)/.*#\1#p' /root/cognee-credentials.txt)
curl -s -o /dev/null -w "http://$H/ -> HTTP %{http_code} %{redirect_url}\n" --resolve "$H:80:127.0.0.1" "http://$H/"
sudo ss -Htln | awk '{print $4}' | sort -u | tr '\n' ' '; echo
A=$(sudo -u nobody curl -s -o /dev/null -m 4 -w '%{http_code}' http://127.0.0.1:8000/health || true)
U=$(sudo -u nobody curl -s -o /dev/null -m 4 -w '%{http_code}' http://127.0.0.1:3000/ || true)
M=$(sudo -u nobody curl -s -o /dev/null -m 4 -w '%{http_code}' http://127.0.0.1:11434/ || true)
echo "another user to the API :8000 -> HTTP $A, the UI :3000 -> HTTP $U, the model :11434 -> HTTP $M" [ "$A" = 000 ] && [ "$U" = 000 ] && [ "$M" = 000 ] && echo FENCED_OK

http://<your-instance-public-dns>/ -> HTTP 301 https://<your-instance-public-dns>/ 0.0.0.0:22 0.0.0.0:443 0.0.0.0:80 127.0.0.1:11434 127.0.0.1:11435 127.0.0.1:3000 127.0.0.1:8000 127.0.0.53%lo:53 127.0.0.54:53 [::]:22 [::]:443 [::]:80 another user to the API :8000 -> HTTP 000, the UI :3000 -> HTTP 000, the model :11434 -> HTTP 000 FENCED_OK

HTTP 000 means the connection was refused: nothing reaches Cognee except through nginx.

sudo cat /root/cognee-credentials.txt

The file is readable by root only. Your values will differ from these:

# cognee - this instance's credentials (sac, minted at first boot). Keep this file secret. COGNEE_URL=https://ec2-<public-ip-dashed>.compute-1.amazonaws.com/ COGNEE_ADMIN_EMAIL=default_user@example.com COGNEE_ADMIN_PASSWORD=<24 or more characters generated on your instance> COGNEE_TLS_SHA256_FINGERPRINT=<unique to your instance> # LLM: the bundled local model qwen2.5:7b-instruct-q4_K_M (Ollama). See the guide to use your own provider key.

The sign-in name is Cognee's own administrator account, default_user@example.com. Its password is unique to your instance, and the upstream default password does not work (first boot proves that before nginx opens).

COGNEE_URL uses the instance's public DNS name from EC2 instance metadata, and the certificate also names the public and private IP addresses. To serve your own DNS name, see Step 12.

Open COGNEE_URL in your browser. The certificate is self-signed for your instance, so the browser warns once. Compare the fingerprint it shows with COGNEE_TLS_SHA256_FINGERPRINT before you accept it.

Sign in with default_user@example.com and COGNEE_ADMIN_PASSWORD. You land on the overview. Panels that mention Cognee Cloud link to the upstream project's separate hosted service, which is not part of this image. Nothing on the instance contacts it.

Add documents to a dataset, then ask questions about them under Search. To use a password of your own, change the administrator password from the interface. The credentials file keeps the original.

Every route except the health check refuses anonymous callers, and sign-up, password reset and e-mail verification are closed. Run this to confirm:

H=$(sudo sed -n 's#^COGNEE_URL=https://\([^/]*\)/.*#\1#p' /root/cognee-credentials.txt) R="--resolve $H:443:127.0.0.1"
ME=$(curl -sk $R -o /dev/null -w '%{http_code}' "https://$H/api/v1/users/me")
DS=$(curl -sk $R -o /dev/null -w '%{http_code}' "https://$H/api/v1/datasets")
REG=$(curl -sk $R -o /dev/null -w '%{http_code}' -H 'Content-Type: application/json' -d '{"email":"someone@example.com","password":"Some-password-1"}' "https://$H/api/v1/auth/register")
FGT=$(curl -sk $R -o /dev/null -w '%{http_code}' -H 'Content-Type: application/json' -d '{"email":"default_user@example.com"}' "https://$H/api/v1/auth/forgot-password")
DEF=$(curl -sk $R -o /dev/null -w '%{http_code}' --data-urlencode 'username=default_user@example.com' --data-urlencode 'password=default_password' "https://$H/api/v1/auth/login")
echo "anonymous /api/v1/users/me -> HTTP $ME";
echo "anonymous /api/v1/datasets -> HTTP $DS"
echo "POST /api/v1/auth/register -> HTTP $REG";
echo "POST /api/v1/auth/forgot-password -> HTTP $FGT"
echo "sign in with the upstream default password -> HTTP $DEF" [ "$ME" = 401 ] && [ "$DS" = 401 ] && [ "$REG" = 403 ] && [ "$FGT" = 403 ] && [ "$DEF" = 400 ] && echo ACCESS_MODEL_OK

anonymous /api/v1/users/me -> HTTP 401 anonymous /api/v1/datasets -> HTTP 401 POST /api/v1/auth/register -> HTTP 403 POST /api/v1/auth/forgot-password -> HTTP 403 sign in with the upstream default password -> HTTP 400 ACCESS_MODEL_OK

• Authentication is required. REQUIRE_AUTHENTICATION=true is set with Cognee's multi-user access control on, so each user sees only their own datasets unless access is shared.
• Sign-up is closed. Only the administrator adds accounts, from the instance itself (Step 11). Password reset and e-mail verification are closed too, because the image runs no mail server.
• The web interface is behind sign-in. nginx asks Cognee whether the caller is signed in before it forwards anything other than a page load to the interface.

Everything in the interface is also available over the REST API. Sign in once and keep the token in a file only you can read. The password is read from the credentials file and passed on standard input, so it never appears in a command line:

H=$(sudo sed -n 's#^COGNEE_URL=https://\([^/]*\)/.*#\1#p' /root/cognee-credentials.txt)
sudo sed -n 's/^COGNEE_ADMIN_PASSWORD=//p' /root/cognee-credentials.txt | tr -d '\n' \
  | curl -s --cacert /etc/nginx/ssl/cognee.crt --resolve "$H:443:127.0.0.1" "https://$H/api/v1/auth/login" \
  --data-urlencode 'username=default_user@example.com' --data-urlencode 'password@-' \
  | jq -r .access_token > ~/.cognee-token chmod 600 ~/.cognee-token curl -s --cacert /etc/nginx/ssl/cognee.crt --resolve "$H:443:127.0.0.1" -H "Authorization: Bearer $(cat ~/.cognee-token)" \
  "https://$H/api/v1/users/me" | jq '{email, is_superuser}'

{ "email": "default_user@example.com", "is_superuser": true }

For scripts and agents, create a long-lived key on the API Keys page. Send it as the X-Api-Key header instead of a bearer token.

Add a short document to a dataset called quickstart:

H=$(sudo sed -n 's#^COGNEE_URL=https://\([^/]*\)/.*#\1#p' /root/cognee-credentials.txt)
cat > /tmp/northwind.txt <<'DOC' Northwind Analytics is a data consultancy founded in 2019 by Priya Raman in Leeds. Its flagship product is Lighthouse, a forecasting tool used by the Harbour Rail company. In 2024 Northwind opened a second office in Bristol, led by Tomas Ferreira. DOC curl -s --cacert /etc/nginx/ssl/cognee.crt --resolve "$H:443:127.0.0.1" -H "Authorization: Bearer $(cat ~/.cognee-token)" \
  -F 'datasetName=quickstart' -F 'data=@/tmp/northwind.txt' "https://$H/api/v1/add" | jq -r .status

PipelineRunCompleted

Run cognify to read the dataset with the language model and build the graph. With the bundled CPU model this takes about fifteen to twenty minutes on m5.xlarge, so start it in the background and check its status:

H=$(sudo sed -n 's#^COGNEE_URL=https://\([^/]*\)/.*#\1#p' /root/cognee-credentials.txt) A=(--cacert /etc/nginx/ssl/cognee.crt --resolve "$H:443:127.0.0.1" -H "Authorization: Bearer $(cat ~/.cognee-token)") curl -s "${A[@]}" -H 'Content-Type: application/json' -d '{"datasets":["quickstart"],"run_in_background":true}' \
  "https://$H/api/v1/cognify" | jq -c '[.[].status] | unique'

["PipelineRunStarted"]

/api/v1/datasets/status reports DATASET_PROCESSING_STARTED while the graph is being built and DATASET_PROCESSING_COMPLETED when it is ready. Then ask a question. This command first waits for the graph, for up to 30 minutes:

# ask-after-cognify
H=$(sudo sed -n 's#^COGNEE_URL=https://\([^/]*\)/.*#\1#p' /root/cognee-credentials.txt) A=(--cacert /etc/nginx/ssl/cognee.crt --resolve "$H:443:127.0.0.1" -H "Authorization: Bearer $(cat ~/.cognee-token)") for i in $(seq 1 180); do curl -s "${A[@]}" "https://$H/api/v1/datasets/status" | jq -e 'length > 0 and all(.[]; test("COMPLETED"))' > /dev/null && break sleep 10 done curl -s "${A[@]}" -H 'Content-Type: application/json' \
  -d '{"query":"Who founded Northwind Analytics, and in which city?","datasets":["quickstart"]}' \
  "https://$H/api/v1/search" | jq -r '.[0].search_result[0]'

Priya Raman founded Northwind Analytics in Leeds.

The answer's wording varies from run to run, but the facts come from your document.

The dataset and its documents also appear under Datasets in the web interface. There you can add files and run the same steps without the API.

The bundled model keeps everything on the instance. For faster processing and stronger answers, point Cognee at a hosted provider. Edit /etc/cognee/cognee.env (readable by root only) and replace the LLM_ lines.

Keep the local embedding settings unchanged. Changing the embedding model on a dataset that already has vectors means rebuilding that dataset. For example, to use OpenAI:

LLM_PROVIDER=openai LLM_MODEL=openai/gpt-4o-mini LLM_ENDPOINT= LLM_API_KEY=<set-at-first-boot>

Restart the API. Once you no longer use the local model, stop it to free its memory:

sudo systemctl restart cognee
sudo systemctl disable --now ollama-proxy.socket ollama

Hosted providers use public addresses, which the egress fence allows. Credentials from the instance role are not available to Cognee because the metadata service is blocked for it, so use an API key.

The egress fence lets Cognee reach public addresses only. To use a private model server, such as an Ollama or vLLM host at 10.0.5.25, list its address in /etc/sac/cognee-egress-allow and reload the fence:

echo '10.0.5.25/32' | sudo tee -a /etc/sac/cognee-egress-allow
sudo systemctl reload cognee-egress-guard

The metadata service and the link-local, loopback and multicast ranges are always refused and cannot be listed.

Sign-up is closed to the network. Create more accounts from the instance itself, as root. Cognee's registration route answers on the loopback address:

sudo curl -s -X POST http://127.0.0.1:8000/api/v1/auth/register \
  -H 'Content-Type: application/json' \
  -d '{"email":"analyst@example.com","password":"<a-strong-password>"}'

Only root, nginx and the web interface may open port 8000, so no other account on the instance can use that route.

Point a DNS record at the instance, then set the name that Cognee is served under. This command mints a new self-signed certificate for the name, updates nginx and the URL and fingerprint in /root/cognee-credentials.txt, and keeps the name across reboots:

sudo cognee-set-hostname <your-domain>

To use a certificate from your own or a public certificate authority instead, install it over the generated pair and reload nginx. Running cognee-set-hostname again replaces it with a self-signed certificate.

sudo install -m 0644 <your-domain>.crt /etc/nginx/ssl/cognee.crt
sudo install -m 0600 <your-domain>.key /etc/nginx/ssl/cognee.key
sudo nginx -t && sudo systemctl reload nginx

List the egress fence rules in force, with each rule's purpose:

sudo nft list table inet sac_cognee_egress | grep -oE 'comment "sac-[a-z0-9]+"' | sort -u

comment "sac-allow" comment "sac-allow6" comment "sac-fence" comment "sac-ipv6" comment "sac-local11434" comment "sac-local11435" comment "sac-local3000" comment "sac-local8000" comment "sac-loopback" comment "sac-metadata" comment "sac-metadata6" comment "sac-modelgate" comment "sac-multicast" comment "sac-private" comment "sac-reply" comment "sac-vpc"

Cognee is refused the metadata service and your VPC, while root on the same instance reaches them (the control). The instance's own SSH port stands in for any service in your VPC:

I=$(sudo curl -s -m 4 -o /dev/null -w '%{http_code}' -X PUT -H 'X-aws-ec2-metadata-token-ttl-seconds: 60' http://169.254.169.254/latest/api/token)
N=$(sudo setpriv --reuid=cognee --regid=cognee --clear-groups curl -s -m 4 -o /dev/null -w '%{http_code}' -X PUT -H 'X-aws-ec2-metadata-token-ttl-seconds: 60' http://169.254.169.254/latest/api/token || true)
P=$(hostname -I | awk '{print $1}')
VR=$(sudo timeout 4 bash -c "exec 3<>/dev/tcp/$P/22" 2>/dev/null && echo OPEN || echo REFUSED)
VN=$(sudo setpriv --reuid=cognee --regid=cognee --clear-groups timeout 4 bash -c "exec 3<>/dev/tcp/$P/22" 2>/dev/null && echo OPEN || echo REFUSED)
echo "metadata service: root HTTP $I, cognee HTTP $N"
echo "own address port 22: root $VR, cognee $VN" [ "$I" = 200 ] && [ "$N" = 000 ] && [ "$VR" = OPEN ] && [ "$VN" = REFUSED ] && echo EGRESS_FENCE_OK

metadata service: root HTTP 200, cognee HTTP 000 own address port 22: root OPEN, cognee REFUSED EGRESS_FENCE_OK

nginx judges the raw request line before it decodes or normalises the path, so encoded slashes, dot segments and doubled slashes are refused. The --path-as-is option sends the path exactly as written:

H=$(sudo sed -n 's#^COGNEE_URL=https://\([^/]*\)/.*#\1#p' /root/cognee-credentials.txt) R="--resolve $H:443:127.0.0.1" OK=1 for p in '/api/v1/auth/%72egister' '/api/v1//auth/register' '/api/v1/x/../auth/register' '/api/v1/auth%2fregister' '/API/V1/AUTH/REGISTER'; do c=$(curl -sk $R --path-as-is -o /dev/null -w '%{http_code}' -H 'Content-Type: application/json' -d '{}' "https://$H$p")
echo "POST $p -> HTTP $c" case "$c" in 400|403|404) ;; *) OK=0 ;; esac done c=$(curl -sk $R -o /dev/null -w '%{http_code}' "https://$H/health");
echo "GET /health -> HTTP $c" [ "$OK" = 1 ] && [ "$c" = 200 ] && echo RAW_LINE_OK

POST /api/v1/auth/%72egister -> HTTP 403 POST /api/v1//auth/register -> HTTP 400 POST /api/v1/x/../auth/register -> HTTP 400 POST /api/v1/auth%2fregister -> HTTP 400 POST /API/V1/AUTH/REGISTER -> HTTP 403 GET /health -> HTTP 200 RAW_LINE_OK

Sign-in is rate-limited to 20 attempts a minute per client, with a burst of 20, and all requests to 3,000 a minute. An IPv4 client is counted by its address and an IPv6 client by its /64 network, so rotating addresses inside one /64 does not reset the limit. A client over the limit gets HTTP 429.

The services run as unprivileged accounts in systemd sandboxes that are blocked from the metadata service, and the secrets are readable by root only:

systemctl show cognee -p User -p NoNewPrivileges -p ProtectSystem -p IPAddressDeny
sudo stat -c '%U:%G %a %n' /etc/cognee /etc/cognee/cognee.env /var/lib/cognee /root/cognee-credentials.txt

IPAddressDeny=168.63.129.16/32 224.0.0.0/4 fd00:ec2::254/128 198.18.0.0/15 192.0.0.0/24 240.0.0.0/4 169.254.169.254/32 User=cognee ProtectSystem=strict NoNewPrivileges=yes root:root 700 /etc/cognee root:root 600 /etc/cognee/cognee.env cognee:cognee 750 /var/lib/cognee root:root 600 /root/cognee-credentials.txt

/opt/cognee/venv/bin/python -c 'import importlib.metadata as m; print("cognee", m.version("cognee"))' /opt/ollama/bin/ollama --version 2>/dev/null | sed -n 's/.*version is /ollama /p' ls /usr/share/doc/cognee cat /usr/share/doc/cognee/BUILD-PROVENANCE.txt

cognee 1.6.7 ollama 0.40.15 BUILD-PROVENANCE.txt LICENSE NOTICE.md uv.lock cognee 1.6.7 (sac build) source: https://github.com/topoteretes/cognee/archive/refs/tags/v1.6.7.tar.gz source sha256: 0eb0224fc1e225e455fc60c2ae403a47f122a763e86dbb7e754aab97458f0797 tag commit: eaa33be5c58cd14584e64e3e0ed2e1479472ee09 uv.lock sha256: 7f5600a58d2aeed2a457cd5639ab835c5a999119e74a1a6d7a806d3e2edad26b (uv 0.13.7 sync --frozen --no-dev --no-editable) raised within range (HIGH advisories): pypdf 6.21.2 -> 6.21.4, dnspython 2.8.0 -> 2.9.0 (sha256-pinned wheels) ladybug JSON extension: linux_amd64 libjson from https://files.pythonhosted.org/packages/py3/c/cognee/cognee-1.6.7-py3-none-any.whl (sha256 fdda7a9a58d463ab4631e817748162e084cf806c597da71d38cac13b2c7e2a51) UI: cognee-frontend @ v1.6.7, package-lock sha256 f0ea05ef9a48ccf96d687d10f7dace6c31704133bdd936d65d5fda5e34b01421, Node v22.23.4; proprietary fonts, logos and avatar removed; server routes pinned to 127.0.0.1:8000; image optimiser disabled Ollama v0.40.15 (CPU backend only), model qwen2.5:7b-instruct-q4_K_M layer sha256:2bada8a7450677000f678be90653b85d364de7db25eb5ea54136ada5f3933730 (Apache-2.0) embedding model BAAI/bge-small-en-v1.5 via Qdrant/bge-small-en-v1.5-onnx-Q (MIT)

Cognee is licensed under the Apache License 2.0. The Qwen2.5 7B Instruct model is Apache 2.0, and the embedding model and Ollama are MIT.

BUILD-PROVENANCE.txt records exactly how the image was built: the source archive and its checksum, the lock files the dependencies were checked against, and the model digests.

The web interface's upstream source includes fonts under proprietary licences and third-party logos. SecureAnyCloud removes them at build time, and the interface uses the open source Geist font instead.