semvec/pypi-packages huggingface dataset:
cich-prompt 0.1.4
Fast multiline terminal input and clipboard library with C++ core
License: MIT
Requires Python: >=3.9
Keywords: input, clipboard, terminal, tui, multiline, editor, prompt, readline

# cich_prompt

Fast multiline terminal input and clipboard library with C++ core and Python bindings.

## Features

- **Multiline Input**: Advanced terminal input with vim-like editing
  - Ctrl+V or /clip: paste from clipboard
  - Ctrl+N: insert newline
  - Ctrl+W/U/K: delete word/to-start/to-end
  - Arrow keys, Home, End navigation
  - Ctrl+Left/Right: word navigation
  - Ctrl+Up/Down: buffer start/end

- **Clipboard**: Cross-platform clipboard operations
  - Supports X11 (xclip, xsel)
  - Supports Wayland (wl-copy, wl-paste)
  - Supports macOS (pbcopy, pbpaste)
  - Supports tmux clipboard
  - Async clipboard fetching with loading indicator

## Installation

```bash
pip install cich_prompt
```

## Quick Start

### Multiline Input

```python
from cich_prompt import multiline_input

# Get user input
text = multiline_input("Enter text: ")
print(f"You entered: {text}")
```

### Clipboard Operations

```python
from cich_prompt.clipboard import set_text, get_text

# Copy to clipboard
set_text("Hello, clipboard!")

# Paste from clipboard
content = get_text()
print(content)
```

### Edit Existing Text

```python
from cich_prompt import multiline_edit

initial = "Edit this text"
result = multiline_edit("Prompt: ", initial)
if result:
    print(f"Edited: {result}")
```

### Auto-return Mode

```python
from cich_prompt import multiline_input_autoreturn

# Auto-submits when input matches an option
options = ["yes", "no", "maybe"]
choice = multiline_input_autoreturn("Choose: ", options)
```

## Requirements

- Python 3.7+
- Linux or macOS (Windows not yet supported)
- C++17 compiler
- CMake 3.15+ (for building from source)

### Platform-Specific

**Linux**: For clipboard support, install one of:
- `xclip` (X11)
- `xsel` (X11)
- `wl-clipboard` (Wayland)

**macOS**: Built-in clipboard support

**Windows**: Not currently supported (uses Unix terminal APIs)

## Building from Source

```bash
git clone https://github.com/akash-sekhon-1/cich
cd cich/python_packages/cich_prompt
pip install -e .
```

## License

MIT License - see LICENSE file

## Author

Akash Sekhon (akashsekhon.de@gmail.com)

## Links

- GitHub: https://github.com/akash-sekhon-1/cich
- PyPI: https://pypi.org/project/cich_prompt/
langgraph-synapse 0.1.0
An integration package connecting Synapse memory and LangGraph. Privacy-first checkpointing and cross-thread memory store.
License: MIT
Requires Python: >=3.10

# langgraph-synapse

An integration package connecting [Synapse](https://github.com/raghuram369/synapse) memory and [LangGraph](https://github.com/langchain-ai/langgraph).

**Privacy-first checkpointing and cross-thread memory** — all data stays local.

## Installation

```bash
pip install langgraph-synapse
```

## Components

### SynapseCheckpointer

Persist LangGraph state across invocations:

```python
from synapse import Synapse
from langgraph_synapse import SynapseCheckpointer

syn = Synapse("./agent_state")
checkpointer = SynapseCheckpointer(synapse=syn)

# Use with LangGraph
graph = builder.compile(checkpointer=checkpointer)
graph.invoke(
    {"messages": [{"role": "user", "content": "hello"}]},
    config={"configurable": {"thread_id": "thread-1"}},
)
```

### SynapseStore

Cross-thread memory store with semantic search:

```python
from synapse import Synapse
from langgraph_synapse import SynapseStore

syn = Synapse("./shared_memory")
store = SynapseStore(synapse=syn)

# Store shared context
store.put(("user", "preferences"), "diet", {"value": "vegetarian"})

# Retrieve across any thread
item = store.get(("user", "preferences"), "diet")

# Semantic search
results = store.search(("user",), query="food preferences")
```

## Why Synapse?

- **🔒 Privacy-first**: All state stays on your machine
- **🧠 Semantic recall**: Not just key-value — find relevant state by meaning
- **⚡ Zero dependencies**: Synapse is pure Python
- **📦 Portable**: `.synapse` files can be shared and federated

## License

MIT
langchain-synapse 0.1.0
An integration package connecting Synapse memory and LangChain. Privacy-first, zero API calls, pure Python.
License: MIT
Requires Python: >=3.10

# langchain-synapse

An integration package connecting [Synapse](https://github.com/raghuram369/synapse) memory and [LangChain](https://github.com/langchain-ai/langchain).

**Privacy-first AI memory** — all data stays local. Zero API calls for storage. Zero external dependencies beyond LangChain and Synapse.

## Installation

```bash
pip install langchain-synapse
```

## Components

### SynapseMemory

Drop-in `BaseMemory` implementation for any LangChain chain:

```python
from langchain_synapse import SynapseMemory
from synapse import Synapse

syn = Synapse("./agent_memory")
memory = SynapseMemory(synapse=syn)

# Use with any chain
chain = prompt | llm
chain.invoke({"input": "hello"}, config={"memory": memory})
```

### SynapseChatMessageHistory

Persistent chat history with semantic recall:

```python
from langchain_synapse import SynapseChatMessageHistory
from synapse import Synapse

syn = Synapse("./chat_memory")
history = SynapseChatMessageHistory(synapse=syn, session_id="user-123")

history.add_user_message("I love Italian food")
history.add_ai_message("Great! Any favorite dish?")

# Semantic search — find relevant messages, not just recent ones
relevant = history.search("What cuisine do they prefer?")
```

### SynapseRetriever

Use Synapse as a retriever in RAG pipelines:

```python
from langchain_synapse import SynapseRetriever
from synapse import Synapse

syn = Synapse("./knowledge_base")
syn.remember("Python was created by Guido van Rossum")
syn.remember("Rust was created by Graydon Hoare at Mozilla")

retriever = SynapseRetriever(synapse=syn, k=5)

# Use in a RAG chain
from langchain_core.runnables import RunnablePassthrough
chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
)
```

## Why Synapse?

- **🔒 Privacy-first**: All memory stays on your machine. No cloud. No API calls for storage.
- **🧠 Neuroscience-inspired**: Memory strengthening, decay, and semantic recall — not just vector similarity.
- **⚡ Zero dependencies**: Synapse itself is pure Python with no external dependencies.
- **📦 Portable**: `.synapse` files can be shared, versioned, and federated across agents.

## License

MIT