GetProfile
GetProfile · Marketing · Leaning
GetProfile is an open source LLM proxy that gives any AI agent persistent memory and a structured user profile. You route your existing OpenAI-compatible requests through it, and it quietly loads what it knows about each user, injects that context into the prompt, then forwards everything to your model provider. It fits teams that already ship a chatbot or assistant and want it to remember returning users instead of starting from zero every session.
About GetProfile
What Is GetProfile
GetProfile is a self-hosted gateway that sits between your app and your LLM provider. Instead of asking a model to guess who it's talking to, it keeps a real profile for each user: a short natural-language summary, typed traits with confidence scores, and a list of relevant memories ranked by importance. That profile lives in a PostgreSQL database you control, not in some vendor's black box.
The problem it solves is memory. Why does that matter? Most assistants forget a user the moment a session ends, and stuffing entire chat logs back into the context window gets expensive fast. GetProfile takes a different route. It extracts only what matters, stores it in a structured shape, and injects a small system message at the right moment.
The catch is deployment. GetProfile is built for developers, so you need Docker, a PostgreSQL instance, and an API key for whatever model you use. There's no polished no-code dashboard yet, and the hosted cloud version is still marked "coming soon." If you don't run your own infrastructure, this isn't a click-and-go product.
Getting Started
- Clone the repository from GitHub and copy the environment example file to
.env. - Add an LLM API key, then set your preferred provider and model in the config file (OpenAI, Anthropic, OpenRouter, or any OpenAI-compatible endpoint).
- Start the proxy and PostgreSQL together with Docker Compose, which brings the gateway up on localhost port 3100.
- Point your OpenAI SDK at that base URL and add the required headers: your GetProfile key, a user identifier, and your upstream provider key.
- Send a normal chat request. GetProfile loads the profile, injects it, forwards the call, and updates the profile in the background.
Product Information
A quick look at GetProfile's pricing, supported platforms, and performance.
Best for
The users, tasks, and scenarios where this tool fits best.
Users
- Backend and AI engineers
- Startup product teams
- Privacy-conscious builders
Tasks
- Adding long-term memory to a chat assistant
- Personalizing responses at scale
- Prototyping agent features locally
- Replacing ad-hoc memory hacks
Scenarios
- A support bot that remembers a customer's past tickets and tone preferences across multiple sessions.
- A tutoring app that tracks what a student has mastered and adjusts explanations accordingly.
- A coding assistant that recalls a developer's stack, patterns, and earlier decisions between work sessions.
- An internal tool where data residency rules forbid sending user profiles to a third-party memory service.
Key features
Drop-In OpenAI API Compatibility
GetProfile works as a replacement for the OpenAI SDK's base URL. If your code already calls chat.completions.create, you swap the endpoint and add headers for the user ID and your upstream key. No rewrites, no new client library, and it works with Anthropic, OpenRouter, or any provider that speaks the OpenAI format. That low-friction swap is the main reason it's easy to try on a live app.
Structured User Profiles
Where generic memory tools store loose blobs of text, GetProfile builds a real profile. It writes a natural-language summary, extracts typed traits with confidence scores, and keeps relevant memories with importance levels. All of it sits in PostgreSQL. The payoff is that your app can query and reason over clean data instead of hoping a model parses a paragraph correctly.
Customizable Traits Schema
You decide what the system should learn about a user. Define which traits matter for your app, how they're pulled from interactions, and how they get injected back into prompts. A language-learning app might track fluency level, while a sales tool tracks deal stage and communication style. Same engine, different shape of personalization.
Automatic Prompt Injection
For every request, GetProfile adds a small system message containing the profile summary, traits, and relevant memories. The team's pitch is that this avoids overloading context windows with long message histories. Only the structured, relevant details go in, and you can see exactly what was injected, which makes the behavior easier to debug than an opaque memory layer.
Background Profile Updates
After a response is returned, GetProfile keeps working. It extracts new traits and memories from the exchange in the background, so the profile improves over time without slowing down the user-facing request. Over many sessions, the assistant gets a richer picture of each person it talks to.
Self-Hosted Deployment with Docker
The whole stack runs in Docker. A lightweight proxy handles requests, PostgreSQL holds the profiles, and the dependencies are deliberately minimal. Docker Compose handles scaling, and because nothing leaves your environment, the data stays under your control. For teams with strict data rules, that's a deciding factor rather than a nice extra.
Apache 2.0 Open Source
GetProfile ships under the Apache 2.0 license, which allows commercial use and modification. The codebase is public on GitHub, so you can audit how memory is extracted and injected, fork it, or extend the traits system for your own needs. There's no vendor lock-in and no seat price to negotiate.
Pros and cons
Pros
- Adds persistent memory to an existing OpenAI-based app with only a base URL change and three headers.
- Stores profiles in a structured form with traits, confidence scores, and importance levels, not loose text.
- Fully self-hosted, so user data stays inside your own PostgreSQL database.
- Apache 2.0 license allows commercial use, modification, and self-hosting with no license fee.
- Works across providers, including OpenAI, Anthropic, OpenRouter, and any OpenAI-compatible endpoint.
Cons
- No hosted option yet, since the cloud service is still "coming soon," so you must run and maintain your own Docker and PostgreSQL setup.
- Aimed at developers with a working OpenAI integration, which rules out non-technical users and no-code workflows.
- Recently launched, so the community is small and there's limited third-party documentation beyond the official docs.
Frequently asked questions
It's an LLM proxy that gives an AI agent long-term memory. It loads a stored user profile, injects relevant traits and memories into each prompt as a system message, sends the request to your model provider, and then updates the profile afterward.
Related content
Explore related tools, skills, and articles for GetProfile.
GetProfile Alternatives
Emailwritr
Emailwritr · Writing · MarketingEmailwritr is an AI email copywriting tool built for affiliates, course creators, and online businesses that want more revenue from the list they already own. Instead of blank pages or generic chatbot prompts, this AI email writer generates welcome sequences, launch campaigns, cart recovery emails, and promo series from frameworks modeled on well-known direct-response copywriters. You connect your autoresponder, answer a few questions about your offer, and it writes the copy for you.
Prosp
Prosp · Writing · Voice & Language · MarketingProsp is an AI LinkedIn outreach tool built for agencies and sales teams, and it writes the message and the voice note in your own voice for each prospect so they actually reply. You connect your accounts, find leads, and let the AI draft and send personalized messages at scale, all from one inbox. It's built for people running outbound at volume. That's the whole pitch. Every touchpoint still has to feel human.
On Model
On Model · Image · MarketingOn Model is an AI fashion model tool that places your clothing on virtual models so online stores can get on-model product photos without booking a photoshoot. It runs as a Shopify app, letting you swap the model in an existing image, change backgrounds, and generate faces for cropped or headless shots. The goal is simple: match your product photos to your customers and stand out from competitors using the same supplier images.