agentmemory-openai 0.1.0__tar.gz

agentmemory_openai-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Devasish Banerjee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentmemory_openai-0.1.0/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: agentmemory-openai
+Version: 0.1.0
+Summary: Persistent memory for OpenAI agents — store, recall, and forget.
+Home-page: https://github.com/bdeva1975/agentmemory
+Author: Devasish Banerjee
+Author-email: your_email@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: httpx>=0.27.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🧠 AgentMemory
+
+**Persistent memory for your OpenAI agents — store, recall, and forget.**
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![OpenAI](https://img.shields.io/badge/powered%20by-OpenAI-412991)
+
+---
+
+## The problem
+
+Every OpenAI agent starts from zero. No memory of past conversations,
+preferences, decisions, or context. Every session is a blank slate.
+
+**AgentMemory solves this — giving your agent durable, queryable memory
+that persists across sessions.**
+
+---
+
+## Quickstart
+
+Install dependencies:
+
+```bash
+pip install openai python-dotenv
+```
+
+Set your OpenAI API key:
+
+```bash
+# .env
+OPENAI_API_KEY=your_key_here
+```
+
+Run your first memory session:
+
+```python
+from agentmemory import AgentMemory
+
+memory = AgentMemory(memory_path="agent_memory.json")
+
+# Store memories from any text
+memory.remember(
+    "I am building a RAG application using Python and OpenAI. "
+    "I prefer concise answers and clean code."
+)
+
+# Recall relevant memories
+results = memory.recall("What is the user building?")
+print(results)
+```
+
+Output:
+
+```
+Found 2 relevant memories:
+  • [CONTEXT] User is building a RAG application using Python and OpenAI
+  • [CONTEXT] User prefers concise answers and clean code
+```
+
+---
+
+## API Reference
+
+```python
+memory = AgentMemory(
+    memory_path="agent_memory.json",  # local storage file
+    model="gpt-4o-mini",              # judge model
+    max_memories=100,                 # max memories to store
+)
+
+memory.remember(text)        # extract and store memories from text
+memory.recall(query, top_k)  # retrieve relevant memories
+memory.forget(memory_id)     # delete a specific memory
+memory.forget_all()          # clear all memories
+memory.list_all()            # return all stored memories
+memory.count                 # total number of memories
+```
+
+---
+
+## Memory categories
+
+| Category | Description |
+|----------|-------------|
+| `fact` | Factual statements about the user or domain |
+| `preference` | User preferences and style choices |
+| `decision` | Decisions made during conversations |
+| `context` | Project or situational context |
+
+---
+
+## Streamlit demo
+
+Run the interactive demo locally:
+
+```bash
+streamlit run app.py
+```
+
+Features:
+
+- Store memories from any text input
+- Search memories with semantic recall
+- View all stored memories in the sidebar
+- Delete individual memories or clear all
+
+---
+
+## How it works
+
+1. `remember(text)` sends the text to GPT-4o-mini which extracts
+   individual factual claims, preferences, decisions, and context.
+2. Each memory is stored as a structured object in a local JSON file.
+3. `recall(query)` sends the query and all stored memories to
+   GPT-4o-mini which scores each memory for relevance.
+4. Memories are returned ranked by relevance score.
+
+All storage is **local** — no cloud, no database, no infrastructure.
+Just a JSON file on your machine.
+
+---
+
+## Cost
+
+Each `remember()` call: **~$0.001**
+
+Each `recall()` call: **~$0.001**
+
+Both use GPT-4o-mini as the judge.
+
+---
+
+## Roadmap
+
+- [ ] Vector embedding search for faster recall at scale
+- [ ] Memory expiry and TTL support
+- [ ] Memory categories and filtering
+- [ ] LangChain and LlamaIndex integration hooks
+- [ ] Multi-agent shared memory support
+
+---
+
+## Project structure
+
+```
+agentmemory/
+├── agentmemory/
+│   ├── __init__.py       # public API
+│   ├── memory.py         # AgentMemory core class
+│   └── models.py         # Memory and MemorySearchResult dataclasses
+├── app.py                # Streamlit demo
+├── example.py            # quickstart example
+├── requirements.txt
+├── .env.example
+└── README.md
+```
+
+---
+
+## License
+
+MIT — free to use, modify, and distribute.
+
+---
+
+## Contributing
+
+Pull requests are welcome. Please open an issue first to discuss
+what you would like to change.
+
+---
+
+*Built with OpenAI GPT-4o-mini as the memory extraction and recall judge.*

agentmemory_openai-0.1.0/README.md

@@ -0,0 +1,175 @@
+# 🧠 AgentMemory
+
+**Persistent memory for your OpenAI agents — store, recall, and forget.**
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![OpenAI](https://img.shields.io/badge/powered%20by-OpenAI-412991)
+
+---
+
+## The problem
+
+Every OpenAI agent starts from zero. No memory of past conversations,
+preferences, decisions, or context. Every session is a blank slate.
+
+**AgentMemory solves this — giving your agent durable, queryable memory
+that persists across sessions.**
+
+---
+
+## Quickstart
+
+Install dependencies:
+
+```bash
+pip install openai python-dotenv
+```
+
+Set your OpenAI API key:
+
+```bash
+# .env
+OPENAI_API_KEY=your_key_here
+```
+
+Run your first memory session:
+
+```python
+from agentmemory import AgentMemory
+
+memory = AgentMemory(memory_path="agent_memory.json")
+
+# Store memories from any text
+memory.remember(
+    "I am building a RAG application using Python and OpenAI. "
+    "I prefer concise answers and clean code."
+)
+
+# Recall relevant memories
+results = memory.recall("What is the user building?")
+print(results)
+```
+
+Output:
+
+```
+Found 2 relevant memories:
+  • [CONTEXT] User is building a RAG application using Python and OpenAI
+  • [CONTEXT] User prefers concise answers and clean code
+```
+
+---
+
+## API Reference
+
+```python
+memory = AgentMemory(
+    memory_path="agent_memory.json",  # local storage file
+    model="gpt-4o-mini",              # judge model
+    max_memories=100,                 # max memories to store
+)
+
+memory.remember(text)        # extract and store memories from text
+memory.recall(query, top_k)  # retrieve relevant memories
+memory.forget(memory_id)     # delete a specific memory
+memory.forget_all()          # clear all memories
+memory.list_all()            # return all stored memories
+memory.count                 # total number of memories
+```
+
+---
+
+## Memory categories
+
+| Category | Description |
+|----------|-------------|
+| `fact` | Factual statements about the user or domain |
+| `preference` | User preferences and style choices |
+| `decision` | Decisions made during conversations |
+| `context` | Project or situational context |
+
+---
+
+## Streamlit demo
+
+Run the interactive demo locally:
+
+```bash
+streamlit run app.py
+```
+
+Features:
+
+- Store memories from any text input
+- Search memories with semantic recall
+- View all stored memories in the sidebar
+- Delete individual memories or clear all
+
+---
+
+## How it works
+
+1. `remember(text)` sends the text to GPT-4o-mini which extracts
+   individual factual claims, preferences, decisions, and context.
+2. Each memory is stored as a structured object in a local JSON file.
+3. `recall(query)` sends the query and all stored memories to
+   GPT-4o-mini which scores each memory for relevance.
+4. Memories are returned ranked by relevance score.
+
+All storage is **local** — no cloud, no database, no infrastructure.
+Just a JSON file on your machine.
+
+---
+
+## Cost
+
+Each `remember()` call: **~$0.001**
+
+Each `recall()` call: **~$0.001**
+
+Both use GPT-4o-mini as the judge.
+
+---
+
+## Roadmap
+
+- [ ] Vector embedding search for faster recall at scale
+- [ ] Memory expiry and TTL support
+- [ ] Memory categories and filtering
+- [ ] LangChain and LlamaIndex integration hooks
+- [ ] Multi-agent shared memory support
+
+---
+
+## Project structure
+
+```
+agentmemory/
+├── agentmemory/
+│   ├── __init__.py       # public API
+│   ├── memory.py         # AgentMemory core class
+│   └── models.py         # Memory and MemorySearchResult dataclasses
+├── app.py                # Streamlit demo
+├── example.py            # quickstart example
+├── requirements.txt
+├── .env.example
+└── README.md
+```
+
+---
+
+## License
+
+MIT — free to use, modify, and distribute.
+
+---
+
+## Contributing
+
+Pull requests are welcome. Please open an issue first to discuss
+what you would like to change.
+
+---
+
+*Built with OpenAI GPT-4o-mini as the memory extraction and recall judge.*

agentmemory_openai-0.1.0/agentmemory/__init__.py

@@ -0,0 +1,5 @@
+from agentmemory.memory import AgentMemory
+from agentmemory.models import Memory, MemorySearchResult
+
+__version__ = "0.1.0"
+__all__ = ["AgentMemory", "Memory", "MemorySearchResult"]

agentmemory_openai-0.1.0/agentmemory/memory.py

@@ -0,0 +1,272 @@
+import os
+import json
+import uuid
+import httpx
+from openai import OpenAI
+from dotenv import load_dotenv
+from typing import List
+from agentmemory.models import Memory, MemorySearchResult
+
+load_dotenv()
+
+_client = None
+
+
+def _get_client() -> OpenAI:
+    """Lazy-initialise the OpenAI client once."""
+    global _client
+    if _client is None:
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise EnvironmentError(
+                "OPENAI_API_KEY not found. "
+                "Set it in your .env file or as an environment variable."
+            )
+        http_client = httpx.Client(verify=False)
+        _client = OpenAI(api_key=api_key, http_client=http_client)
+    return _client
+
+
+_EXTRACT_PROMPT = """
+You are a memory extraction assistant.
+
+Given a conversation message, extract all factual claims, preferences, 
+decisions, or important context that an AI agent should remember for 
+future conversations.
+
+Return ONLY a valid JSON object with a single key "memories" containing an array.
+No explanation. No markdown. Raw JSON only.
+
+Each item must follow this schema:
+{
+  "content": "the memory to store as a short clear sentence",
+  "category": "fact | preference | decision | context"
+}
+
+Example output:
+{"memories": [
+  {"content": "User prefers Python over JavaScript", "category": "preference"},
+  {"content": "User is building a RAG application", "category": "context"}
+]}
+
+If nothing meaningful to extract, return {"memories": []}
+""".strip()
+
+_SEARCH_PROMPT = """
+You are a memory relevance judge.
+
+Given a query and a list of memories, return the indices of memories 
+that are relevant to the query, along with a relevance score.
+
+Return ONLY a valid JSON object with a single key "results" containing an array.
+No explanation. No markdown. Raw JSON only.
+
+Each item must follow this schema:
+{
+  "index": 0,
+  "relevance": 0.95
+}
+
+Return {"results": []} if no memories are relevant.
+Relevance score must be between 0.0 and 1.0.
+Only include memories with relevance >= 0.5.
+""".strip()
+
+
+class AgentMemory:
+    """
+    Persistent memory store for OpenAI agents.
+
+    Stores memories in a local JSON file and retrieves
+    relevant memories using GPT-4o-mini as a semantic judge.
+
+    Usage:
+        memory = AgentMemory(memory_path="agent_memory.json")
+        memory.remember("User told me they prefer concise answers.")
+        results = memory.recall("What does the user prefer?")
+        print(results)
+    """
+
+    def __init__(
+        self,
+        memory_path: str = "agent_memory.json",
+        model: str = "gpt-4o-mini",
+        max_memories: int = 100,
+    ):
+        self.memory_path = memory_path
+        self.model = model
+        self.max_memories = max_memories
+        self._memories: List[Memory] = []
+        self._load()
+
+    def _load(self):
+        """Load memories from the JSON file."""
+        if os.path.exists(self.memory_path):
+            try:
+                with open(self.memory_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    self._memories = [Memory(**m) for m in data]
+            except Exception:
+                self._memories = []
+
+    def _save(self):
+        """Save memories to the JSON file."""
+        with open(self.memory_path, "w", encoding="utf-8") as f:
+            json.dump(
+                [m.__dict__ for m in self._memories],
+                f,
+                indent=2,
+                ensure_ascii=False,
+            )
+
+    def remember(self, text: str) -> List[Memory]:
+        """
+        Extract and store memories from a text input.
+
+        Args:
+            text: conversation message or any text to extract memories from
+
+        Returns:
+            List of Memory objects that were stored
+        """
+        if not text or not text.strip():
+            return []
+
+        client = _get_client()
+
+        try:
+            completion = client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": _EXTRACT_PROMPT},
+                    {"role": "user", "content": text.strip()},
+                ],
+                temperature=0,
+                response_format={"type": "json_object"},
+            )
+            raw = completion.choices[0].message.content
+        except Exception as e:
+            return []
+
+        try:
+            parsed = json.loads(raw)
+            items = parsed.get("memories", [])
+        except json.JSONDecodeError:
+            return []
+
+        new_memories = []
+        for item in items:
+            if isinstance(item, dict) and "content" in item:
+                memory = Memory(
+                    id=str(uuid.uuid4()),
+                    content=item["content"],
+                    category=item.get("category", "fact"),
+                )
+                self._memories.append(memory)
+                new_memories.append(memory)
+
+        if len(self._memories) > self.max_memories:
+            self._memories = self._memories[-self.max_memories:]
+
+        self._save()
+        return new_memories
+
+    def recall(
+        self,
+        query: str,
+        top_k: int = 5,
+    ) -> MemorySearchResult:
+        """
+        Retrieve memories relevant to a query.
+
+        Args:
+            query: the question or context to search memories for
+            top_k: maximum number of memories to return
+
+        Returns:
+            MemorySearchResult with relevant memories and scores
+        """
+        if not self._memories:
+            return MemorySearchResult(query=query)
+
+        if not query or not query.strip():
+            return MemorySearchResult(query=query)
+
+        client = _get_client()
+
+        memories_list = "\n".join(
+            f"{i}: {m.content} [{m.category}]"
+            for i, m in enumerate(self._memories)
+        )
+
+        try:
+            completion = client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": _SEARCH_PROMPT},
+                    {
+                        "role": "user",
+                        "content": f"QUERY: {query.strip()}\n\nMEMORIES:\n{memories_list}",
+                    },
+                ],
+                temperature=0,
+                response_format={"type": "json_object"},
+            )
+            raw = completion.choices[0].message.content
+        except Exception as e:
+            return MemorySearchResult(query=query)
+
+        try:
+            parsed = json.loads(raw)
+            items = parsed.get("results", [])
+        except json.JSONDecodeError:
+            return MemorySearchResult(query=query)
+
+        relevant = []
+        for item in items:
+            if isinstance(item, dict) and "index" in item:
+                idx = item["index"]
+                if 0 <= idx < len(self._memories):
+                    memory = self._memories[idx]
+                    memory.relevance = float(item.get("relevance", 0.5))
+                    relevant.append(memory)
+
+        relevant.sort(key=lambda m: m.relevance, reverse=True)
+        relevant = relevant[:top_k]
+
+        return MemorySearchResult(
+            memories=relevant,
+            query=query,
+            total_found=len(relevant),
+        )
+
+    def forget(self, memory_id: str) -> bool:
+        """
+        Delete a specific memory by ID.
+
+        Args:
+            memory_id: the ID of the memory to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        original_count = len(self._memories)
+        self._memories = [m for m in self._memories if m.id != memory_id]
+        if len(self._memories) < original_count:
+            self._save()
+            return True
+        return False
+
+    def forget_all(self):
+        """Clear all memories."""
+        self._memories = []
+        self._save()
+
+    def list_all(self) -> List[Memory]:
+        """Return all stored memories."""
+        return self._memories.copy()
+
+    @property
+    def count(self) -> int:
+        """Total number of stored memories."""
+        return len(self._memories)

agentmemory_openai-0.1.0/agentmemory/models.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass, field
+from typing import List
+from datetime import datetime
+
+
+@dataclass
+class Memory:
+    """
+    A single memory entry stored by the agent.
+
+    Attributes:
+        id          : unique memory identifier
+        content     : the fact or information extracted from conversation
+        category    : type of memory (fact, preference, decision, context)
+        created_at  : timestamp when memory was created
+        relevance   : relevance score when retrieved (0.0 - 1.0)
+    """
+    id: str
+    content: str
+    category: str = "fact"
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    relevance: float = 0.0
+
+    def __str__(self) -> str:
+        return f"[{self.category.upper()}] {self.content}"
+
+
+@dataclass
+class MemorySearchResult:
+    """
+    Result returned when searching agent memories.
+
+    Attributes:
+        memories    : list of relevant Memory objects
+        query       : the search query used
+        total_found : total number of memories found
+    """
+    memories: List[Memory] = field(default_factory=list)
+    query: str = ""
+    total_found: int = 0
+
+    def __str__(self) -> str:
+        if not self.memories:
+            return "No relevant memories found."
+        lines = [f"Found {self.total_found} relevant memories:"]
+        for m in self.memories:
+            lines.append(f"  • {m}")
+        return "\n".join(lines)

agentmemory_openai-0.1.0/agentmemory_openai.egg-info/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: agentmemory-openai
+Version: 0.1.0
+Summary: Persistent memory for OpenAI agents — store, recall, and forget.
+Home-page: https://github.com/bdeva1975/agentmemory
+Author: Devasish Banerjee
+Author-email: your_email@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: httpx>=0.27.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🧠 AgentMemory
+
+**Persistent memory for your OpenAI agents — store, recall, and forget.**
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![OpenAI](https://img.shields.io/badge/powered%20by-OpenAI-412991)
+
+---
+
+## The problem
+
+Every OpenAI agent starts from zero. No memory of past conversations,
+preferences, decisions, or context. Every session is a blank slate.
+
+**AgentMemory solves this — giving your agent durable, queryable memory
+that persists across sessions.**
+
+---
+
+## Quickstart
+
+Install dependencies:
+
+```bash
+pip install openai python-dotenv
+```
+
+Set your OpenAI API key:
+
+```bash
+# .env
+OPENAI_API_KEY=your_key_here
+```
+
+Run your first memory session:
+
+```python
+from agentmemory import AgentMemory
+
+memory = AgentMemory(memory_path="agent_memory.json")
+
+# Store memories from any text
+memory.remember(
+    "I am building a RAG application using Python and OpenAI. "
+    "I prefer concise answers and clean code."
+)
+
+# Recall relevant memories
+results = memory.recall("What is the user building?")
+print(results)
+```
+
+Output:
+
+```
+Found 2 relevant memories:
+  • [CONTEXT] User is building a RAG application using Python and OpenAI
+  • [CONTEXT] User prefers concise answers and clean code
+```
+
+---
+
+## API Reference
+
+```python
+memory = AgentMemory(
+    memory_path="agent_memory.json",  # local storage file
+    model="gpt-4o-mini",              # judge model
+    max_memories=100,                 # max memories to store
+)
+
+memory.remember(text)        # extract and store memories from text
+memory.recall(query, top_k)  # retrieve relevant memories
+memory.forget(memory_id)     # delete a specific memory
+memory.forget_all()          # clear all memories
+memory.list_all()            # return all stored memories
+memory.count                 # total number of memories
+```
+
+---
+
+## Memory categories
+
+| Category | Description |
+|----------|-------------|
+| `fact` | Factual statements about the user or domain |
+| `preference` | User preferences and style choices |
+| `decision` | Decisions made during conversations |
+| `context` | Project or situational context |
+
+---
+
+## Streamlit demo
+
+Run the interactive demo locally:
+
+```bash
+streamlit run app.py
+```
+
+Features:
+
+- Store memories from any text input
+- Search memories with semantic recall
+- View all stored memories in the sidebar
+- Delete individual memories or clear all
+
+---
+
+## How it works
+
+1. `remember(text)` sends the text to GPT-4o-mini which extracts
+   individual factual claims, preferences, decisions, and context.
+2. Each memory is stored as a structured object in a local JSON file.
+3. `recall(query)` sends the query and all stored memories to
+   GPT-4o-mini which scores each memory for relevance.
+4. Memories are returned ranked by relevance score.
+
+All storage is **local** — no cloud, no database, no infrastructure.
+Just a JSON file on your machine.
+
+---
+
+## Cost
+
+Each `remember()` call: **~$0.001**
+
+Each `recall()` call: **~$0.001**
+
+Both use GPT-4o-mini as the judge.
+
+---
+
+## Roadmap
+
+- [ ] Vector embedding search for faster recall at scale
+- [ ] Memory expiry and TTL support
+- [ ] Memory categories and filtering
+- [ ] LangChain and LlamaIndex integration hooks
+- [ ] Multi-agent shared memory support
+
+---
+
+## Project structure
+
+```
+agentmemory/
+├── agentmemory/
+│   ├── __init__.py       # public API
+│   ├── memory.py         # AgentMemory core class
+│   └── models.py         # Memory and MemorySearchResult dataclasses
+├── app.py                # Streamlit demo
+├── example.py            # quickstart example
+├── requirements.txt
+├── .env.example
+└── README.md
+```
+
+---
+
+## License
+
+MIT — free to use, modify, and distribute.
+
+---
+
+## Contributing
+
+Pull requests are welcome. Please open an issue first to discuss
+what you would like to change.
+
+---
+
+*Built with OpenAI GPT-4o-mini as the memory extraction and recall judge.*

agentmemory_openai-0.1.0/agentmemory_openai.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+agentmemory/__init__.py
+agentmemory/memory.py
+agentmemory/models.py
+agentmemory_openai.egg-info/PKG-INFO
+agentmemory_openai.egg-info/SOURCES.txt
+agentmemory_openai.egg-info/dependency_links.txt
+agentmemory_openai.egg-info/requires.txt
+agentmemory_openai.egg-info/top_level.txt

agentmemory_openai-0.1.0/agentmemory_openai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentmemory_openai-0.1.0/agentmemory_openai.egg-info/requires.txt

@@ -0,0 +1,3 @@
+openai>=1.0.0
+python-dotenv>=1.0.0
+httpx>=0.27.0

agentmemory_openai-0.1.0/agentmemory_openai.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentmemory

agentmemory_openai-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agentmemory_openai-0.1.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="agentmemory-openai",
+    version="0.1.0",
+    author="Devasish Banerjee",
+    author_email="your_email@gmail.com",
+    description="Persistent memory for OpenAI agents — store, recall, and forget.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/bdeva1975/agentmemory",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+    python_requires=">=3.10",
+    install_requires=[
+        "openai>=1.0.0",
+        "python-dotenv>=1.0.0",
+        "httpx>=0.27.0",
+    ],
+)