graphiti-render/render.yaml at main · render-examples/graphiti-render · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
# Graphiti on Render — a temporal knowledge graph API backed by FalkorDB.
#
# graphiti-api      public REST service, built from the repo's root Dockerfile
# graphiti-falkordb the graph store, private: reachable only from graphiti-api
#
# No secrets here: OPENAI_API_KEY is sync: false, so Render prompts at deploy time.

previews:
  # Quoted, because bare off is a YAML boolean and the schema types this field as a string
  # enum — unquoted it fails `render blueprints validate`.
  generation: 'off'

projects:
  - name: graphiti
    environments:
      - name: production
        services:
          - type: pserv
            name: graphiti-falkordb
            runtime: image
            region: oregon
            # FalkorDB keeps the whole graph in RAM, so the plan is the real ceiling on
            # graph size. Standard (2 GB) is the smallest with room to grow.
            plan: standard
            # Pinned, not :latest, so an upstream bump can't break new deploys.
            image:
              url: docker.io/falkordb/falkordb:v4.20.1
            disk:
              name: falkordb-data
              mountPath: /var/lib/falkordb/data
              sizeGB: 10
            envVars:
              # Append-only file, so the graph survives a restart or redeploy.
              - key: REDIS_ARGS
                value: --appendonly yes
              # The image also serves the FalkorDB Browser on :3000. Unused here, and off
              # leaves 6379 as the only port Render's scanner can pick.
              - key: BROWSER
                value: '0'

          - type: web
            name: graphiti-api
            runtime: docker
            region: oregon
            # The API idles near 100 MB and spends most of each request waiting on OpenAI.
            plan: starter
            dockerfilePath: ./Dockerfile
            dockerContext: .
            healthCheckPath: /healthcheck
            envVars:
              # On the service, not in an env var group: sync: false is silently ignored
              # inside a group, so Render would never prompt for the value.
              - key: OPENAI_API_KEY
                sync: false

              # Bearer token for every endpoint except /healthcheck; the server won't start
              # without it, so a fork is closed from the moment it goes live. Read the value
              # from the Dashboard (Environment tab) after the first deploy.
              #
              # generateValue rather than sync: false keeps the one-click path one click. It
              # persists across syncs, so rotation is a manual edit here or in the Dashboard;
              # a replacement must be 16+ printable-ASCII characters (see config.py).
              - key: GRAPHITI_API_KEY
                generateValue: true

              # The port uvicorn binds to and the one Render routes to. Declared so the first
              # deploy doesn't start on Render's default 10000, detect the real port, and
              # restart to rewire the network. Safe to change: the CMD passes it through.
              - key: PORT
                value: '8000'

              # Render passes env vars to the Docker build as build args, which is how the
              # root Dockerfile picks up the graphiti-core FalkorDB extra.
              - key: INSTALL_FALKORDB
                value: 'true'
              # GRAPHITI_VERSION is deliberately unset: it's pinned once as the Dockerfile's
              # build-arg default, so a bump is one line. Setting it here overrides that pin
              # for this service only.

              - key: DB_BACKEND
                value: falkordb
              - key: FALKORDB_HOST
                fromService:
                  name: graphiti-falkordb
                  type: pserv
                  property: host
              - key: FALKORDB_PORT
                value: '6379'
              - key: FALKORDB_DATABASE
                value: default_db

              # The model Graphiti uses to extract entities and facts. Any OpenAI model id.
              - key: MODEL_NAME
                value: gpt-5.5
              # Concurrent LLM calls during ingestion. Below graphiti-core's default of 20 so
              # a burst of episodes doesn't trip rate limits on a new OpenAI key.
              - key: SEMAPHORE_LIMIT
                value: '10'