hipcortex 0.2.0__py3-none-any.whl

hipcortex/client.py

@@ -0,0 +1,223 @@
+"""HipCortex HTTP client — thin wrapper around the REST API."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional
+
+import requests
+
+
+class HipCortexClient:
+    """Synchronous HTTP client for the HipCortex memory server.
+
+    Args:
+        base_url: Root URL of the running hipcortex web-server binary.
+        timeout:  Per-request timeout in seconds.
+    """
+
+    def __init__(self, base_url: str = "http://localhost:3000", timeout: float = 10.0) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = requests.Session()
+
+    # ------------------------------------------------------------------
+    # Core memory operations
+    # ------------------------------------------------------------------
+
+    def add_memory(
+        self,
+        actor: str,
+        action: str,
+        target: str,
+        record_type: str = "Temporal",
+        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[List[str]] = None,
+        priority: str = "normal",  # "pinned"|"high"|"normal"|"low"
+    ) -> Dict[str, Any]:
+        """Store a memory record.
+
+        Returns the server response dict with ``success`` and ``record_id``.
+        """
+        payload = {
+            "actor": actor,
+            "action": action,
+            "target": target,
+            "record_type": record_type,
+            "metadata": metadata or {},
+        }
+        if tags:
+            payload["tags"] = tags
+        if priority != "normal":
+            payload["priority"] = priority
+        resp = self._session.post(
+            f"{self.base_url}/memory/add", json=payload, timeout=self.timeout
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def query_memory(
+        self,
+        actor: Optional[str] = None,
+        action: Optional[str] = None,
+        record_type: Optional[str] = None,
+        limit: int = 100,
+        tags: Optional[List[str]] = None,    # filter by tags (any match)
+        as_of: Optional[str] = None,         # ISO 8601 timestamp for time-travel query
+    ) -> List[Dict[str, Any]]:
+        """Query memory records. Returns a list of record dicts."""
+        params: Dict[str, Any] = {"limit": limit}
+        if actor is not None:
+            params["actor"] = actor
+        if action is not None:
+            params["action"] = action
+        if record_type is not None:
+            params["record_type"] = record_type
+        if tags is not None:
+            params["tags"] = ",".join(tags)
+        if as_of is not None:
+            params["as_of"] = as_of
+        resp = self._session.get(
+            f"{self.base_url}/memory/query", params=params, timeout=self.timeout
+        )
+        resp.raise_for_status()
+        return resp.json().get("records", [])
+
+    def search(
+        self,
+        query: str,
+        embedding: Optional[List[float]] = None,
+        limit: int = 10,
+    ) -> List[Dict[str, Any]]:
+        """Semantic + keyword search over stored memory records.
+
+        If ``embedding`` is provided, ranks results by cosine similarity
+        against records that carry a ``metadata.embedding`` float array.
+        Falls back to keyword matching when embeddings are absent.
+
+        Returns a list of ``{"score": float, "record": {...}}`` dicts,
+        sorted by descending score.
+        """
+        payload: Dict[str, Any] = {"query": query, "limit": limit}
+        if embedding is not None:
+            payload["embedding"] = embedding
+        resp = self._session.post(
+            f"{self.base_url}/memory/search", json=payload, timeout=self.timeout
+        )
+        resp.raise_for_status()
+        return resp.json().get("results", [])
+
+    def forget(self, actor: str) -> Dict[str, Any]:
+        """GDPR right-to-forget: delete all records for ``actor``.
+
+        Returns ``{"success": bool, "records_deleted": int, "symbolic_nodes_deleted": int}``.
+        """
+        resp = self._session.delete(
+            f"{self.base_url}/memory/forget/{actor}", timeout=self.timeout
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    # ------------------------------------------------------------------
+    # Symbolic graph
+    # ------------------------------------------------------------------
+
+    def graph(self) -> Dict[str, Any]:
+        """Return the full symbolic graph (nodes + edges)."""
+        resp = self._session.get(f"{self.base_url}/graph", timeout=self.timeout)
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_node(self, node_id: str) -> Optional[Dict[str, Any]]:
+        """Fetch a single symbolic node by UUID."""
+        resp = self._session.get(f"{self.base_url}/node/{node_id}", timeout=self.timeout)
+        resp.raise_for_status()
+        return resp.json()
+
+    # ------------------------------------------------------------------
+    # System
+    # ------------------------------------------------------------------
+
+    def health(self) -> bool:
+        """Return True if server is reachable and healthy."""
+        try:
+            resp = self._session.get(f"{self.base_url}/health", timeout=self.timeout)
+            return resp.status_code == 200
+        except requests.RequestException:
+            return False
+
+    def coherence_status(self) -> Dict[str, Any]:
+        """Return the current coherence metrics from the server."""
+        resp = self._session.get(f"{self.base_url}/coherence/status", timeout=self.timeout)
+        resp.raise_for_status()
+        return resp.json()
+
+    def stats(self) -> Dict[str, Any]:
+        """Return live server statistics: record counts, type breakdown, metering state."""
+        resp = self._session.get(f"{self.base_url}/stats", timeout=self.timeout)
+        resp.raise_for_status()
+        return resp.json()
+
+    # ------------------------------------------------------------------
+    # Convenience helpers used by framework adapters
+    # ------------------------------------------------------------------
+
+    def add_human_message(self, session_id: str, content: str) -> Dict[str, Any]:
+        return self.add_memory(
+            actor=session_id,
+            action="human_message",
+            target=content,
+            record_type="Temporal",
+        )
+
+    def add_ai_message(self, session_id: str, content: str) -> Dict[str, Any]:
+        return self.add_memory(
+            actor=session_id,
+            action="ai_message",
+            target=content,
+            record_type="Reflexion",
+        )
+
+    def get_conversation_history(
+        self, session_id: str, limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        return self.query_memory(actor=session_id, limit=limit)
+
+    def create_node(self, label: str, properties: Optional[Dict[str, str]] = None) -> Dict[str, Any]:
+        """Create a symbolic knowledge graph node."""
+        resp = self._session.post(
+            f"{self.base_url}/graph/node",
+            json={"label": label, "properties": properties or {}},
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def create_edge(self, from_id: str, to_id: str, relation: str) -> Dict[str, Any]:
+        """Create a relationship edge in the knowledge graph."""
+        resp = self._session.post(
+            f"{self.base_url}/graph/edge",
+            json={"from_id": from_id, "to_id": to_id, "relation": relation},
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def consolidate(self, actor: Optional[str] = None, threshold: float = 0.8, dry_run: bool = True) -> Dict[str, Any]:
+        """Find near-duplicate memories and optionally merge them."""
+        params: Dict[str, Any] = {"threshold": threshold, "dry_run": dry_run}
+        if actor is not None:
+            params["actor"] = actor
+        resp = self._session.post(
+            f"{self.base_url}/memory/consolidate",
+            params=params,
+            timeout=self.timeout,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def ping_latency_ms(self) -> float:
+        """Return round-trip latency to /health in milliseconds."""
+        t0 = time.perf_counter()
+        self.health()
+        return (time.perf_counter() - t0) * 1000

hipcortex/install/SKILL.md

@@ -0,0 +1,114 @@
+# HipCortex Memory
+
+HipCortex gives you persistent causal memory across sessions. Store decisions, recall context, forget on request.
+
+## When to use
+
+Invoke HipCortex when the user asks you to:
+- Remember something ("remember that we use JWT")
+- Recall past context ("what did we decide about the database?")
+- Forget data ("forget everything about project X")
+- Store a decision, bug fix, or architectural note
+
+## How to use
+
+**Store a memory:**
+```
+POST http://localhost:3030/memory/add
+{"actor": "<project-or-user>", "action": "decided", "target": "<what to remember>"}
+```
+
+**Search memories:**
+```
+GET http://localhost:3030/memory/search-flat?query=<topic>&limit=10
+Returns: {"memories": ["[action] target", ...]}
+```
+
+**Forget (GDPR):**
+```
+DELETE http://localhost:3030/memory/forget/<actor>
+```
+
+**Stats:**
+```
+GET http://localhost:3030/stats
+```
+
+## Slash commands
+
+When the user types `/hipcortex remember <text>` — call POST /memory/add with actor=current-project-name.
+When the user types `/hipcortex recall <query>` — call GET /memory/search-flat?query=<query>.
+When the user types `/hipcortex latest <topic>` — call GET /memory/latest?actor=<project>&action=<topic> to get the most recent fact.
+When the user types `/hipcortex update <id> <corrected text>` — call PATCH /memory/update/<id> with {"target": "<corrected text>"} to fix a wrong memory.
+When the user types `/hipcortex forget <actor>` — call DELETE /memory/forget/<actor>.
+When the user types `/hipcortex stats` — call GET /stats and display the result.
+
+## Correction workflow
+
+When the user says "that's wrong, it should be X" about a previously stored memory:
+1. Search for the wrong memory: GET /memory/search-flat?query=<topic>
+2. Get the record id from the result
+3. Update it: PATCH /memory/update/<id> {"target": "<correct text>", "confidence": 1.0}
+4. Confirm: "✓ Memory corrected (version N)"
+
+## Confidence scoring
+
+When storing uncertain or inferred information, include confidence:
+POST /memory/add {"confidence": 0.6, "source": "inferred", ...}
+When storing verified user-provided facts: confidence=1.0 (default)
+When storing LLM-generated inferences: confidence=0.7
+When storing speculation: confidence=0.3
+
+## Tags and priority
+
+When storing memories, add tags for RAG filtering:
+```
+POST /memory/add {"tags": ["architecture", "decision"], "priority": "normal", ...}
+```
+
+Priority values:
+- "pinned" — always returned in search, bypass decay. Use for safety constraints, hard rules.
+- "high" — weighted higher in results
+- "normal" — default
+- "low" — fades faster
+
+Example: store an allergy constraint that must never be forgotten:
+POST /memory/add {"priority": "pinned", "confidence": 1.0, "action": "constraint", "target": "User is allergic to penicillin"}
+
+## Knowledge graph
+
+Write relationships to the symbolic knowledge graph:
+```
+POST /graph/node {"label": "Alice", "properties": {"role": "CEO"}}
+POST /graph/edge {"from_id": "<alice-uuid>", "to_id": "<project-uuid>", "relation": "MANAGES"}
+GET /graph  → view full graph
+```
+
+## Time-travel queries
+
+Query memory state at a past timestamp:
+GET /memory/query?as_of=2026-01-15T00:00:00Z&actor=alice
+
+Useful for auditing: "what did the agent know about user alice on January 15th?"
+
+## Deduplication
+
+Find near-duplicate memories:
+POST /memory/consolidate?actor=my-project&threshold=0.8&dry_run=true
+→ Returns pairs of similar records with "keep" and "drop" IDs
+→ Use GDPR forget to remove duplicates: DELETE /memory/forget/<actor> for specific cleanup
+
+## Auto-memory mode
+
+If the user says "remember this" at the end of any message, automatically store a summary of the conversation turn in HipCortex before responding.
+
+## Default actor
+
+Use the current git repository name as the actor (run `git rev-parse --show-toplevel | xargs basename` to get it). Fall back to "default" if not in a git repo.
+
+## Server
+
+Default: http://localhost:3030
+Managed free tier: https://hipcortex.fly.dev (set HIPCORTEX_URL to override)
+
+The server must be running. If unreachable, tell the user to run: `hipcortex start`

hipcortex/install/__init__.py

@@ -0,0 +1 @@
+# HipCortex install package — contains SKILL.md for Claude Code registration

hipcortex/langchain_memory.py

@@ -0,0 +1,238 @@
+"""LangChain-compatible memory backed by HipCortex.
+
+Drop-in replacement for ``ConversationBufferMemory`` in any LangChain chain.
+
+Usage::
+
+    from hipcortex import HipCortexClient
+    from hipcortex.langchain_memory import HipCortexMemory
+    from langchain.chains import ConversationChain
+    from langchain.chat_models import ChatOpenAI
+
+    client = HipCortexClient(base_url="http://localhost:3000")
+    memory = HipCortexMemory(client=client, session_id="user-42")
+
+    chain = ConversationChain(llm=ChatOpenAI(), memory=memory)
+    chain.predict(input="Hello!")
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from .client import HipCortexClient
+
+try:
+    from langchain.schema import BaseMemory
+    from langchain.schema.messages import AIMessage, HumanMessage, BaseMessage
+    _LANGCHAIN_AVAILABLE = True
+except ImportError:
+    _LANGCHAIN_AVAILABLE = False
+    # Provide a no-op base so the class can be imported without LangChain installed
+    class BaseMemory:  # type: ignore[no-redef]
+        def save_context(self, inputs: Dict, outputs: Dict) -> None: ...
+        def load_memory_variables(self, inputs: Dict) -> Dict: ...
+        def clear(self) -> None: ...
+
+
+class HipCortexMemory(BaseMemory):
+    """LangChain ``BaseMemory`` implementation backed by HipCortex REST API.
+
+    Args:
+        client:     Configured :class:`~hipcortex.client.HipCortexClient`.
+        session_id: Scopes all memory reads/writes to this actor identifier.
+        memory_key: Key used when injecting history into the chain's prompt vars
+                    (default: ``"history"``).
+        human_prefix: Label prepended to human turns in the history string.
+        ai_prefix:    Label prepended to AI turns in the history string.
+        max_records:  Max records fetched per ``load_memory_variables`` call.
+    """
+
+    # Not using pydantic model here to stay LangChain version-agnostic
+
+    def __init__(
+        self,
+        client: HipCortexClient,
+        session_id: str = "default",
+        memory_key: str = "history",
+        human_prefix: str = "Human",
+        ai_prefix: str = "AI",
+        max_records: int = 50,
+    ) -> None:
+        self.client = client
+        self.session_id = session_id
+        self.memory_key = memory_key
+        self.human_prefix = human_prefix
+        self.ai_prefix = ai_prefix
+        self.max_records = max_records
+
+    # Required by BaseMemory -------------------------------------------------
+
+    @property
+    def memory_variables(self) -> List[str]:
+        return [self.memory_key]
+
+    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Fetch conversation history from HipCortex and format as a string."""
+        records = self.client.get_conversation_history(
+            self.session_id, limit=self.max_records
+        )
+        # Sort oldest-first
+        records.sort(key=lambda r: r.get("timestamp", ""))
+
+        lines: List[str] = []
+        for rec in records:
+            action = rec.get("action", "")
+            target = rec.get("target", "")
+            if action == "human_message":
+                lines.append(f"{self.human_prefix}: {target}")
+            elif action == "ai_message":
+                lines.append(f"{self.ai_prefix}: {target}")
+
+        return {self.memory_key: "\n".join(lines)}
+
+    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, Any]) -> None:
+        """Persist a human→AI exchange to HipCortex."""
+        human_text = inputs.get("input") or inputs.get("human_input") or ""
+        ai_text = outputs.get("output") or outputs.get("response") or ""
+        if human_text:
+            self.client.add_human_message(self.session_id, str(human_text))
+        if ai_text:
+            self.client.add_ai_message(self.session_id, str(ai_text))
+
+    def clear(self) -> None:
+        """Invoke GDPR forget for the current session."""
+        self.client.forget(self.session_id)
+
+    # Optional helper --------------------------------------------------------
+
+    def get_messages(self) -> List[Any]:
+        """Return conversation history as LangChain ``BaseMessage`` objects.
+
+        Requires LangChain to be installed; raises ``ImportError`` otherwise.
+        """
+        if not _LANGCHAIN_AVAILABLE:
+            raise ImportError("langchain is required: pip install langchain")
+        records = self.client.get_conversation_history(
+            self.session_id, limit=self.max_records
+        )
+        records.sort(key=lambda r: r.get("timestamp", ""))
+        messages: List[BaseMessage] = []
+        for rec in records:
+            target = rec.get("target", "")
+            if rec.get("action") == "human_message":
+                messages.append(HumanMessage(content=target))
+            elif rec.get("action") == "ai_message":
+                messages.append(AIMessage(content=target))
+        return messages
+
+
+class AsyncHipCortexMemory:
+    """Async-native LangChain BaseMemory backed by AsyncHipCortexClient.
+
+    Use with async LangChain chains (LangChain 0.2+, FastAPI, Django async).
+    Implements aload_memory_variables and asave_context as coroutines.
+
+    Usage::
+
+        from hipcortex import AsyncHipCortexClient
+        from hipcortex.langchain_memory import AsyncHipCortexMemory
+
+        async def chat(user_input: str):
+            client = AsyncHipCortexClient("http://localhost:3030")
+            memory = AsyncHipCortexMemory(client=client, session_id="user-42")
+            history = await memory.aload_memory_variables({})
+            await memory.asave_context({"input": user_input}, {"output": ai_response})
+    """
+
+    def __init__(
+        self,
+        client: "Any",
+        session_id: str = "default",
+        memory_key: str = "history",
+        human_prefix: str = "Human",
+        ai_prefix: str = "AI",
+        max_limit: int = 50,
+    ) -> None:
+        self._client = client
+        self.session_id = session_id
+        self.memory_key = memory_key
+        self.human_prefix = human_prefix
+        self.ai_prefix = ai_prefix
+        self.max_limit = max_limit
+
+    @property
+    def memory_variables(self) -> List[str]:
+        return [self.memory_key]
+
+    async def aload_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Fetch conversation history as formatted string (async)."""
+        records = await self._client.get_conversation_history(
+            self.session_id, limit=self.max_limit
+        )
+        records.sort(key=lambda r: r.get("timestamp", ""))
+        lines: List[str] = []
+        for rec in records:
+            action = rec.get("action", "")
+            target = rec.get("target", "")
+            if action == "human_message":
+                lines.append(f"{self.human_prefix}: {target}")
+            elif action == "ai_message":
+                lines.append(f"{self.ai_prefix}: {target}")
+        return {self.memory_key: "\n".join(lines)}
+
+    async def asave_context(
+        self, inputs: Dict[str, Any], outputs: Dict[str, Any]
+    ) -> None:
+        """Persist a human->AI exchange asynchronously."""
+        human_text = inputs.get("input") or inputs.get("human_input") or ""
+        ai_text    = outputs.get("output") or outputs.get("response") or ""
+        if human_text:
+            await self._client.add_human_message(self.session_id, str(human_text))
+        if ai_text:
+            await self._client.add_ai_message(self.session_id, str(ai_text))
+
+    async def aclear(self) -> None:
+        """GDPR forget for this session."""
+        await self._client.forget(self.session_id)
+
+    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Sync fallback using asyncio.run()."""
+        import asyncio
+        import concurrent.futures
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                with concurrent.futures.ThreadPoolExecutor() as pool:
+                    return pool.submit(asyncio.run, self.aload_memory_variables(inputs)).result()
+            return loop.run_until_complete(self.aload_memory_variables(inputs))
+        except RuntimeError:
+            return asyncio.run(self.aload_memory_variables(inputs))
+
+    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, Any]) -> None:
+        """Sync fallback using asyncio.run()."""
+        import asyncio
+        import concurrent.futures
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                with concurrent.futures.ThreadPoolExecutor() as pool:
+                    pool.submit(asyncio.run, self.asave_context(inputs, outputs)).result()
+                return
+            loop.run_until_complete(self.asave_context(inputs, outputs))
+        except RuntimeError:
+            asyncio.run(self.asave_context(inputs, outputs))
+
+    def clear(self) -> None:
+        """Sync fallback using asyncio.run()."""
+        import asyncio
+        import concurrent.futures
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                with concurrent.futures.ThreadPoolExecutor() as pool:
+                    pool.submit(asyncio.run, self.aclear()).result()
+                return
+            loop.run_until_complete(self.aclear())
+        except RuntimeError:
+            asyncio.run(self.aclear())

hipcortex/llamaindex_storage.py

@@ -0,0 +1,107 @@
+"""LlamaIndex storage context wrapper backed by HipCortex.
+
+Provides a ``HipCortexStorageContext`` that can be passed wherever LlamaIndex
+accepts a ``StorageContext``, and a ``HipCortexChatStore`` compatible with
+``SimpleChatStore`` for chat-engine memory.
+
+Usage::
+
+    from hipcortex import HipCortexClient
+    from hipcortex.llamaindex_storage import HipCortexChatStore
+    from llama_index.core.memory import ChatMemoryBuffer
+
+    client = HipCortexClient(base_url="http://localhost:3000")
+    store = HipCortexChatStore(client=client)
+
+    memory = ChatMemoryBuffer.from_defaults(
+        token_limit=3000,
+        chat_store=store,
+        chat_store_key="user-42",
+    )
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Sequence
+
+from .client import HipCortexClient
+
+
+class HipCortexChatStore:
+    """Drop-in for ``SimpleChatStore`` in LlamaIndex chat engines.
+
+    Stores each chat message as a HipCortex ``MemoryRecord`` keyed by
+    ``session_key`` (the ``chat_store_key`` param in LlamaIndex).
+    """
+
+    def __init__(self, client: HipCortexClient) -> None:
+        self.client = client
+
+    # LlamaIndex SimpleChatStore interface ----------------------------------
+
+    def set_messages(self, key: str, messages: Sequence[Any]) -> None:
+        """Overwrite messages for ``key`` by forgetting then re-adding."""
+        self.client.forget(key)
+        for msg in messages:
+            role = getattr(msg, "role", "user")
+            content = getattr(msg, "content", str(msg))
+            action = "ai_message" if role in ("assistant", "ai") else "human_message"
+            self.client.add_memory(
+                actor=key,
+                action=action,
+                target=content,
+                record_type="Temporal" if role != "assistant" else "Reflexion",
+            )
+
+    def get_messages(self, key: str) -> List[Any]:
+        """Return raw record dicts (caller converts to ChatMessage objects)."""
+        records = self.client.get_conversation_history(key, limit=200)
+        records.sort(key=lambda r: r.get("timestamp", ""))
+        return records
+
+    def add_message(self, key: str, message: Any) -> None:
+        role = getattr(message, "role", "user")
+        content = getattr(message, "content", str(message))
+        action = "ai_message" if role in ("assistant", "ai") else "human_message"
+        self.client.add_memory(
+            actor=key,
+            action=action,
+            target=content,
+            record_type="Temporal" if role != "assistant" else "Reflexion",
+        )
+
+    def delete_messages(self, key: str) -> Optional[List[Any]]:
+        msgs = self.get_messages(key)
+        self.client.forget(key)
+        return msgs
+
+    def delete_message(self, key: str, idx: int) -> Optional[Any]:
+        """Not efficiently supported; falls back to forget-and-reinsert."""
+        msgs = self.get_messages(key)
+        if idx < 0 or idx >= len(msgs):
+            return None
+        removed = msgs.pop(idx)
+        self.set_messages(key, msgs)  # type: ignore[arg-type]
+        return removed
+
+    def get_keys(self) -> List[str]:
+        """Returns empty list — full key enumeration requires graph query."""
+        return []
+
+
+class HipCortexStorageContext:
+    """Lightweight wrapper that holds a ``HipCortexChatStore`` and exposes
+    a ``StorageContext``-like surface for LlamaIndex.
+
+    For simple use-cases (chat engines, memory buffers) this is sufficient.
+    For full index persistence (VectorStore, DocStore, IndexStore) use
+    LlamaIndex's native backends alongside HipCortex for chat memory only.
+    """
+
+    def __init__(self, client: HipCortexClient) -> None:
+        self.client = client
+        self.chat_store = HipCortexChatStore(client=client)
+
+    @classmethod
+    def from_url(cls, base_url: str = "http://localhost:3000") -> "HipCortexStorageContext":
+        return cls(client=HipCortexClient(base_url=base_url))