synapse-pkg 0.1.1__tar.gz

synapse_pkg-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2026 Piyush Garg
+
+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.

synapse_pkg-0.1.1/PKG-INFO

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: synapse-pkg
+Version: 0.1.1
+Summary: Knowledge graph extraction library powered by LLMs
+Author: Piyush Garg
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: google-generativeai
+Dynamic: license-file
+
+# 🧠 Synapse
+
+> Transform natural language into a persistent knowledge graph.
+
+Synapse is a Python library that converts unstructured text into a structured knowledge graph by extracting concepts and relationships from natural language.
+
+Instead of storing information as raw text, Synapse organizes information into a graph structure that can be queried, traversed, and extended for building intelligent systems and memory systems.
+
+---
+
+## ✨ Features
+
+- Natural language → structured relationships
+- Persistent graph storage
+- Duplicate prevention
+- Case-insensitive querying
+- Multi-hop relationship traversal
+- Local-first architecture
+- Provider-agnostic design
+- Extensible memory engine
+
+---
+
+## 📦 Installation
+
+```bash
+pip install synapse-ai
+```
+
+---
+
+## ⚡ Quick Start
+
+```python
+from synapse import Synapse
+
+brain = Synapse()
+
+brain.add(
+    "CEO of Apple met Microsoft executives in Seattle."
+)
+
+brain.save()
+
+print(
+    brain.get_relations("Apple")
+)
+
+print(
+    brain.get_indirect_relations("CEO of Apple")
+)
+```
+
+---
+
+## Example
+
+### Input
+
+```text
+Python is used for AI and TensorFlow is used in AI.
+```
+
+### Extracted Graph
+
+```python
+{
+    "python": [
+        ("used_for", "ai")
+    ],
+    "tensorflow": [
+        ("used_in", "ai")
+    ]
+}
+```
+
+---
+
+## Project Structure
+
+```text
+synapse/
+├── __init__.py
+├── synapse.py
+├── graph.py
+├── query.py
+├── processor.py
+├── extractor.py
+├── persistence.py
+└── utils.py
+```
+
+---
+
+## ⚙️ Design Principles
+
+- Simplicity over complexity
+- Local-first architecture
+- Incremental development
+- Extensibility
+- No overengineering
+
+---
+
+## 📌 Current Status
+
+### ✅ V1 Complete
+
+Implemented features:
+
+- Text ingestion
+- Relationship extraction
+- Graph construction
+- Graph persistence
+- Query system
+- Multi-hop traversal
+- Python package support
+- Provider-agnostic extractor architecture
+
+---
+
+# 🗺️ Roadmap
+
+## V2 — Conversational Memory Layer
+
+Build a conversational interface on top of the graph.
+
+Planned capabilities:
+
+- Memory-backed conversations
+- Graph-aware retrieval
+- Contextual question answering
+- Better reasoning over stored knowledge
+- Persistent long-term memory
+
+---
+
+## V3 — Agentic Knowledge Graph
+
+Integrate coding agents and sandboxed environments.
+
+Planned capabilities:
+
+- Claude Code integration
+- Codex integration
+- Live graph construction during conversations
+- Automatic graph updates
+- Multi-session memory
+- Knowledge graph visualization
+
+---
+
+## V4 — Portable Intelligence
+
+Turn Synapse into a transferable memory engine.
+
+Planned capabilities:
+
+- Import knowledge graphs
+- Export knowledge graphs
+- Transfer memory between LLMs
+- Local execution
+- Offline mode
+- Personal AI memory system
+
+Example:
+
+```text
+Claude
+    ↓
+Knowledge Graph
+    ↓
+Export
+    ↓
+GPT
+    ↓
+Continue with the same memory
+```
+
+---
+
+## 🚀 Vision
+
+Modern AI systems own the intelligence, but they also own the memory.
+
+Synapse aims to separate the two.
+
+The long-term goal is to make memory portable, persistent, and independent of any single model provider.
+
+Memory should belong to the user, not the model.
+
+---
+
+## 🧑‍💻 Author
+
+### Piyush Garg
+
+AI/ML enthusiast interested in:
+
+- Knowledge Graphs
+- LLM Systems
+- Intelligent Agents
+- Machine Learning Infrastructure
+
+Building systems at the intersection of memory and intelligence.
+
+---
+
+## 📄 License
+
+MIT License

synapse_pkg-0.1.1/README.md

@@ -0,0 +1,211 @@
+# 🧠 Synapse
+
+> Transform natural language into a persistent knowledge graph.
+
+Synapse is a Python library that converts unstructured text into a structured knowledge graph by extracting concepts and relationships from natural language.
+
+Instead of storing information as raw text, Synapse organizes information into a graph structure that can be queried, traversed, and extended for building intelligent systems and memory systems.
+
+---
+
+## ✨ Features
+
+- Natural language → structured relationships
+- Persistent graph storage
+- Duplicate prevention
+- Case-insensitive querying
+- Multi-hop relationship traversal
+- Local-first architecture
+- Provider-agnostic design
+- Extensible memory engine
+
+---
+
+## 📦 Installation
+
+```bash
+pip install synapse-ai
+```
+
+---
+
+## ⚡ Quick Start
+
+```python
+from synapse import Synapse
+
+brain = Synapse()
+
+brain.add(
+    "CEO of Apple met Microsoft executives in Seattle."
+)
+
+brain.save()
+
+print(
+    brain.get_relations("Apple")
+)
+
+print(
+    brain.get_indirect_relations("CEO of Apple")
+)
+```
+
+---
+
+## Example
+
+### Input
+
+```text
+Python is used for AI and TensorFlow is used in AI.
+```
+
+### Extracted Graph
+
+```python
+{
+    "python": [
+        ("used_for", "ai")
+    ],
+    "tensorflow": [
+        ("used_in", "ai")
+    ]
+}
+```
+
+---
+
+## Project Structure
+
+```text
+synapse/
+├── __init__.py
+├── synapse.py
+├── graph.py
+├── query.py
+├── processor.py
+├── extractor.py
+├── persistence.py
+└── utils.py
+```
+
+---
+
+## ⚙️ Design Principles
+
+- Simplicity over complexity
+- Local-first architecture
+- Incremental development
+- Extensibility
+- No overengineering
+
+---
+
+## 📌 Current Status
+
+### ✅ V1 Complete
+
+Implemented features:
+
+- Text ingestion
+- Relationship extraction
+- Graph construction
+- Graph persistence
+- Query system
+- Multi-hop traversal
+- Python package support
+- Provider-agnostic extractor architecture
+
+---
+
+# 🗺️ Roadmap
+
+## V2 — Conversational Memory Layer
+
+Build a conversational interface on top of the graph.
+
+Planned capabilities:
+
+- Memory-backed conversations
+- Graph-aware retrieval
+- Contextual question answering
+- Better reasoning over stored knowledge
+- Persistent long-term memory
+
+---
+
+## V3 — Agentic Knowledge Graph
+
+Integrate coding agents and sandboxed environments.
+
+Planned capabilities:
+
+- Claude Code integration
+- Codex integration
+- Live graph construction during conversations
+- Automatic graph updates
+- Multi-session memory
+- Knowledge graph visualization
+
+---
+
+## V4 — Portable Intelligence
+
+Turn Synapse into a transferable memory engine.
+
+Planned capabilities:
+
+- Import knowledge graphs
+- Export knowledge graphs
+- Transfer memory between LLMs
+- Local execution
+- Offline mode
+- Personal AI memory system
+
+Example:
+
+```text
+Claude
+    ↓
+Knowledge Graph
+    ↓
+Export
+    ↓
+GPT
+    ↓
+Continue with the same memory
+```
+
+---
+
+## 🚀 Vision
+
+Modern AI systems own the intelligence, but they also own the memory.
+
+Synapse aims to separate the two.
+
+The long-term goal is to make memory portable, persistent, and independent of any single model provider.
+
+Memory should belong to the user, not the model.
+
+---
+
+## 🧑‍💻 Author
+
+### Piyush Garg
+
+AI/ML enthusiast interested in:
+
+- Knowledge Graphs
+- LLM Systems
+- Intelligent Agents
+- Machine Learning Infrastructure
+
+Building systems at the intersection of memory and intelligence.
+
+---
+
+## 📄 License
+
+MIT License

synapse_pkg-0.1.1/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "synapse-pkg"
+version = "0.1.1"
+description = "Knowledge graph extraction library powered by LLMs"
+readme = "README.md"
+requires-python = ">=3.10"
+
+authors = [
+    { name = "Piyush Garg" }
+]
+
+dependencies = [    
+    "google-generativeai",
+    ]

synapse_pkg-0.1.1/setup.cfg

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

synapse_pkg-0.1.1/synapse/__init__.py

@@ -0,0 +1 @@
+from .synapse import Synapse

synapse_pkg-0.1.1/synapse/extractor.py

@@ -0,0 +1,63 @@
+from dotenv import load_dotenv
+import os
+from google import genai
+
+load_dotenv()
+client = genai.Client()
+
+prompt_template = """you are an information extractor system whose work is to extract information in 
+the specified schema and return the output in the specified type only 
+RETURN ONLY THE VALID JSON
+
+Extract:-
+    1. Concepts
+    2. Relationships
+
+RETURN OUTPUT USING THIS SCHEMA ONLY
+{{
+  "concepts": [],
+  "relationships": [
+    {{
+      "source": "",
+      "relation": "",
+      "target": ""
+    }}
+  ]
+}}
+text: {input_text}
+
+BELOW IS AN EXAMPLE ON HOW THE OUTPUT SHOULD LOOK LIKE
+
+
+text: Python is used for AI and Tensorflow is used in AI
+{{
+  "concepts": [
+    "Python",
+    "TensorFlow",
+    "AI"
+  ],
+  "relationships": [
+    {{
+      "source": "Python",
+      "relation": "used_for",
+      "target": "AI"
+    }},
+    {{
+      "source": "TensorFlow",
+      "relation": "used_in",
+      "target": "AI"
+    }}
+  ]
+}}
+"""
+
+def generate_prompt(user_text):
+  prompt = prompt_template.format(input_text=user_text)
+  return prompt
+
+def extractor(prompt):
+  response = client.models.generate_content(
+      model="gemini-2.5-flash",
+      contents=prompt,
+  )
+  return response

synapse_pkg-0.1.1/synapse/graph.py

@@ -0,0 +1,19 @@
+from .utils import normalize
+def add_relationship(
+    graph:dict,
+    source:str,
+    relation:str, 
+    target:str
+    ):
+    source = normalize(source)
+    relation = normalize(relation)
+    target = normalize(target)
+    tup = (relation,target)
+
+    graph.setdefault(source,[])
+    if tup in graph[source]:
+        return graph
+    else:
+        graph[source].append(tup)
+    return graph
+    

synapse_pkg-0.1.1/synapse/persistence.py

@@ -0,0 +1,22 @@
+import json
+GRAPH_FILE = 'graph.json'
+
+def save(graph:dict):
+    json_graph = {source: [list(item) for item in relation]
+                   for source,relation in graph.items()
+    }
+    with open(GRAPH_FILE,'w') as f:
+        json.dump(json_graph,f)
+
+def load_graph():
+    try:
+        with open(GRAPH_FILE,'r') as f:
+            json_graph = json.load(f)
+    except FileNotFoundError:
+        return {}
+
+    loaded_graph = {
+        source: [tuple(item) for item in relation]
+        for source,relation in json_graph.items()
+    }
+    return loaded_graph

synapse_pkg-0.1.1/synapse/processor.py

@@ -0,0 +1,25 @@
+import json
+from .extractor import generate_prompt,extractor
+
+def process_text(user_text:str,extractor):
+
+    """
+    Extract structured relationships from text using an LLM.
+    """
+
+    prompt = generate_prompt(user_text)
+    raw_response = extractor(prompt)
+    cleaned_text = (
+        raw_response.text
+        .replace("```json", "")
+        .replace("```", "")
+        .strip()
+    )
+    try:
+        parsed_response = json.loads(cleaned_text)
+        return parsed_response
+    except json.JSONDecodeError:
+        return {
+            "concepts":[],
+            "relationships":[]
+        }

synapse_pkg-0.1.1/synapse/query.py

@@ -0,0 +1,40 @@
+from .utils import normalize
+def get_relations(
+    graph:dict, 
+    concept:str,
+    relation:str | None=None
+    ):
+
+    """
+    Return all relations for a concept.
+
+    Optionally filter by relation type.
+    """
+
+    if not concept.strip() or not concept:
+        return []
+    concept = normalize(concept)
+    relations = graph.get(concept, [])
+    if relation is None:
+        return relations
+    return [
+        (relation_name,target)
+        for relation_name,target in relations
+        if relation_name.lower() == relation.lower()
+    ]
+
+def get_indirect_relations(
+    graph:dict, 
+    source:str
+    ):
+    if not source.strip() or not source:
+        return []
+    source = normalize(source)
+    res=[]
+    relations = get_relations(graph, source)
+    for relation, target in relations:
+        if target in graph:
+            secondary_relations = get_relations(graph, target)
+            for secondary_relation, secondary_target in secondary_relations:
+                res.append((relation, target, secondary_relation, secondary_target))
+    return res

synapse_pkg-0.1.1/synapse/synapse.py

@@ -0,0 +1,37 @@
+from .persistence import save,load_graph
+from .query import get_relations, get_indirect_relations
+from .processor import process_text
+from .graph import add_relationship
+from .extractor import extractor
+class Synapse:
+    def __init__(self):
+        self.graph={}
+
+
+    def save(self):
+        save(self.graph)
+
+
+    def load_graph(self):
+        self.graph = load_graph()
+
+
+    def get_relations(
+        self,
+        concept:str,
+        relation:str | None=None
+        ):
+        return get_relations(self.graph,concept)
+
+
+    def get_indirect_relations(self,source:str):
+        return get_indirect_relations(self.graph,source)
+
+
+    def add(self,text:str):
+        if not text.strip():
+            return
+        parsed_response=process_text(text)
+        relationships = parsed_response['relationships']
+        for rel in relationships:
+            add_relationship(self.graph, rel['source'], rel['relation'], rel['target'])

synapse_pkg-0.1.1/synapse/utils.py

@@ -0,0 +1,2 @@
+def normalize(text):
+    return text.strip().lower()

synapse_pkg-0.1.1/synapse_pkg.egg-info/PKG-INFO

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: synapse-pkg
+Version: 0.1.1
+Summary: Knowledge graph extraction library powered by LLMs
+Author: Piyush Garg
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: google-generativeai
+Dynamic: license-file
+
+# 🧠 Synapse
+
+> Transform natural language into a persistent knowledge graph.
+
+Synapse is a Python library that converts unstructured text into a structured knowledge graph by extracting concepts and relationships from natural language.
+
+Instead of storing information as raw text, Synapse organizes information into a graph structure that can be queried, traversed, and extended for building intelligent systems and memory systems.
+
+---
+
+## ✨ Features
+
+- Natural language → structured relationships
+- Persistent graph storage
+- Duplicate prevention
+- Case-insensitive querying
+- Multi-hop relationship traversal
+- Local-first architecture
+- Provider-agnostic design
+- Extensible memory engine
+
+---
+
+## 📦 Installation
+
+```bash
+pip install synapse-ai
+```
+
+---
+
+## ⚡ Quick Start
+
+```python
+from synapse import Synapse
+
+brain = Synapse()
+
+brain.add(
+    "CEO of Apple met Microsoft executives in Seattle."
+)
+
+brain.save()
+
+print(
+    brain.get_relations("Apple")
+)
+
+print(
+    brain.get_indirect_relations("CEO of Apple")
+)
+```
+
+---
+
+## Example
+
+### Input
+
+```text
+Python is used for AI and TensorFlow is used in AI.
+```
+
+### Extracted Graph
+
+```python
+{
+    "python": [
+        ("used_for", "ai")
+    ],
+    "tensorflow": [
+        ("used_in", "ai")
+    ]
+}
+```
+
+---
+
+## Project Structure
+
+```text
+synapse/
+├── __init__.py
+├── synapse.py
+├── graph.py
+├── query.py
+├── processor.py
+├── extractor.py
+├── persistence.py
+└── utils.py
+```
+
+---
+
+## ⚙️ Design Principles
+
+- Simplicity over complexity
+- Local-first architecture
+- Incremental development
+- Extensibility
+- No overengineering
+
+---
+
+## 📌 Current Status
+
+### ✅ V1 Complete
+
+Implemented features:
+
+- Text ingestion
+- Relationship extraction
+- Graph construction
+- Graph persistence
+- Query system
+- Multi-hop traversal
+- Python package support
+- Provider-agnostic extractor architecture
+
+---
+
+# 🗺️ Roadmap
+
+## V2 — Conversational Memory Layer
+
+Build a conversational interface on top of the graph.
+
+Planned capabilities:
+
+- Memory-backed conversations
+- Graph-aware retrieval
+- Contextual question answering
+- Better reasoning over stored knowledge
+- Persistent long-term memory
+
+---
+
+## V3 — Agentic Knowledge Graph
+
+Integrate coding agents and sandboxed environments.
+
+Planned capabilities:
+
+- Claude Code integration
+- Codex integration
+- Live graph construction during conversations
+- Automatic graph updates
+- Multi-session memory
+- Knowledge graph visualization
+
+---
+
+## V4 — Portable Intelligence
+
+Turn Synapse into a transferable memory engine.
+
+Planned capabilities:
+
+- Import knowledge graphs
+- Export knowledge graphs
+- Transfer memory between LLMs
+- Local execution
+- Offline mode
+- Personal AI memory system
+
+Example:
+
+```text
+Claude
+    ↓
+Knowledge Graph
+    ↓
+Export
+    ↓
+GPT
+    ↓
+Continue with the same memory
+```
+
+---
+
+## 🚀 Vision
+
+Modern AI systems own the intelligence, but they also own the memory.
+
+Synapse aims to separate the two.
+
+The long-term goal is to make memory portable, persistent, and independent of any single model provider.
+
+Memory should belong to the user, not the model.
+
+---
+
+## 🧑‍💻 Author
+
+### Piyush Garg
+
+AI/ML enthusiast interested in:
+
+- Knowledge Graphs
+- LLM Systems
+- Intelligent Agents
+- Machine Learning Infrastructure
+
+Building systems at the intersection of memory and intelligence.
+
+---
+
+## 📄 License
+
+MIT License

synapse_pkg-0.1.1/synapse_pkg.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+synapse/__init__.py
+synapse/extractor.py
+synapse/graph.py
+synapse/persistence.py
+synapse/processor.py
+synapse/query.py
+synapse/synapse.py
+synapse/utils.py
+synapse_pkg.egg-info/PKG-INFO
+synapse_pkg.egg-info/SOURCES.txt
+synapse_pkg.egg-info/dependency_links.txt
+synapse_pkg.egg-info/requires.txt
+synapse_pkg.egg-info/top_level.txt

synapse_pkg-0.1.1/synapse_pkg.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

synapse_pkg-0.1.1/synapse_pkg.egg-info/requires.txt

@@ -0,0 +1 @@
+google-generativeai

synapse_pkg-0.1.1/synapse_pkg.egg-info/top_level.txt

@@ -0,0 +1 @@
+synapse