Claude Memory Manager

What It Does

Installation

pip install psutil tqdm

Usage

python claude_memory_manager.py --prompt "Your prompt here" --max-chunk-size 2000

Source Code

import argparse
import logging
import psutil
from tqdm import tqdm

# Removed anthropic import as it caused issues

def setup_logging():
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s'
    )

def monitor_memory(max_memory):
    """Monitor system memory usage and log warnings if usage exceeds limits."""
    memory = psutil.virtual_memory()
    logging.info(f"Total memory: {memory.total / (1024 ** 2):.2f} MB")
    logging.info(f"Available memory: {memory.available / (1024 ** 2):.2f} MB")

    if memory.available < max_memory * 1024 ** 2:
        logging.warning("Memory usage is nearing the limit!")
        return False
    return True

def segment_prompt(prompt, max_chunk_size):
    """Segment a large prompt into smaller chunks."""
    chunks = []
    current_chunk = []
    current_size = 0

    for line in prompt.splitlines():
        line_size = len(line.encode('utf-8'))
        if current_size + line_size > max_chunk_size:
            chunks.append('\n'.join(current_chunk))
            current_chunk = []
            current_size = 0
        current_chunk.append(line)
        current_size += line_size

    if current_chunk:
        chunks.append('\n'.join(current_chunk))

    return chunks

def clear_memory():
    """Simulate clearing memory."""
    logging.info("Memory cleared.")

def interact_with_claude(prompt, max_chunk_size):
    """Simulate sending prompt to Claude AI in memory-efficient chunks."""
    chunks = segment_prompt(prompt, max_chunk_size)

    responses = []
    for chunk in tqdm(chunks, desc="Processing chunks"):
        try:
            # Simulate a response
            response = {"completion": f"Processed chunk: {chunk}"}
            responses.append(response['completion'])
        except Exception as e:
            logging.error(f"Error interacting with Claude AI: {e}")
            responses.append("Error occurred")

    return responses

def main():
    setup_logging()

    parser = argparse.ArgumentParser(
        description="Claude Memory Manager: Optimize memory usage for Claude AI sessions."
    )
    parser.add_argument('--monitor-memory', action='store_true', help="Monitor memory usage.")
    parser.add_argument('--max-memory', type=int, default=8000, help="Maximum memory limit in MB.")
    parser.add_argument('--clear-memory', action='store_true', help="Clear memory.")
    parser.add_argument('--prompt', type=str, help="Prompt to send to Claude AI.")
    parser.add_argument('--max-chunk-size', type=int, default=2000, help="Maximum chunk size in bytes.")

    args = parser.parse_args()

    if args.monitor_memory:
        if not monitor_memory(args.max_memory):
            logging.warning("Memory usage exceeded the limit!")

    if args.clear_memory:
        clear_memory()

    if args.prompt:
        responses = interact_with_claude(args.prompt, args.max_chunk_size)
        for i, response in enumerate(responses, start=1):
            logging.info(f"Response {i}: {response}")

if __name__ == "__main__":
    main()