Skip to main content

​
Architecture Overview

GetProfile provides the LLM Proxy for automatic, transparent integration with your existing OpenAI-compatible applications.

​
Proxy Flow (Automatic)

The proxy sits between your application and the LLM provider, enriching every request with user context automatically. 
┌───────────────┐     ┌──────────────────────────────────┐     ┌─────────────────┐
│               │     │         GetProfile Proxy         │     │                 │
│   Your App    │────▶│                                  │────▶│   LLM Provider  │
│               │     │  1. Load user profile            │     │   (OpenAI, etc) │
│               │     │  2. Retrieve relevant memories   │     │                 │
└───────────────┘     │  3. Inject context into prompt   │     └─────────────────┘
                      │  4. Forward to LLM               │
                      │  5. Stream response back         │
                      │  6. Extract traits (background)  │
                      └──────────────────────────────────┘

​
Request Flow

1

Request Received

Your app sends a chat completion request to the GetProfile proxy with a user identifier.
2

Profile Loaded

GetProfile looks up the user’s profile using the X-GetProfile-Id header or user field.
3

Context Assembled

The proxy gathers:
  • User traits (name, preferences, expertise level)
  • Profile summary
  • Relevant memories from past conversations
4

Prompt Enriched

Context is injected into the system message: ``` ## User Profile Alex is an experienced software engineer who prefers concise, technical explanations. ## User Attributes - Communication style: technical - Expertise level: advanced

​
Relevant Context - User mentioned working on a microservices migration last

week ```
5

Request Forwarded

The enriched request is sent to the upstream LLM provider.
6

Response Streamed

The LLM response is streamed back to your app in real-time.
7

Background Processing

After the response completes, GetProfile asynchronously:
  • Extracts new traits from the conversation
  • Stores relevant memories
  • Updates the profile summary if needed

​
Three-Layer Architecture

┌─────────────────────────────────────────────────────────────────┐
│                        PRESENTATION LAYER                       │
├───────────────┬───────────────┬─────────────────────────────────┤
│   LLM Proxy   │  Profile API  │            Dashboard            │
│  (automatic)  │     (SDK or REST)    │       (Cloud version only)      │
└───────────────┴───────────────┴─────────────────────────────────┘
                                │
┌─────────────────────────────────────────────────────────────────────┐
│                         CORE ENGINE LAYER                           │
├────────────────────────────┬───────────────────────────────────────┤
│      Memory Engine         │         Trait Engine                   │
│  - Message storage         │  - Schema management                   │
│  - Fact extraction         │  - Trait extraction                    │
│  - Memory retrieval        │  - Confidence scoring                  │
│  - Summarization           │  - Profile summary generation          │
└────────────────────────────┴───────────────────────────────────────┘
                              │
┌─────────────────────────────────────────────────────────────────────┐
│                         STORAGE LAYER                                │
├────────────────────────────┬───────────────────────────────────────┤
│      PostgreSQL            │         (Optional) Redis               │
│  - Profiles                │  - Profile summary cache               │
│  - Traits                  │  - Hot memory cache                    │
│  - Messages                │  - Rate limiting                       │
│  - Memories (pgvector)     │                                        │
└────────────────────────────┴───────────────────────────────────────┘
All integration methods (Proxy, API, Dashboard) share the same core engine and storage, ensuring consistent behavior regardless of how you integrate.

​
Key Components

Responsible for: - Storing conversation messages - Extracting facts and memories using LLM - Retrieving relevant memories for context - Generating profile summaries
Responsible for: - Loading trait schemas (default + custom) - Extracting structured traits from conversations - Managing confidence scores - Building injection context
Orchestrates: - Profile creation and lookup - Context assembly for requests
  • Coordinating memory and trait engines

​
Choosing an Integration

If you need…Use
Automatic memory on every LLM callLLM Proxy
Backend integration in Node.jsJavaScript SDK
REST API for custom clientsProfile API
See the Integration Options guide for detailed comparison.