DEV Community

Cover image for I Built a Tool to Search AI Conversations in 1 Week (With Heavy AI Assistance)
D P
D P

Posted on

I Built a Tool to Search AI Conversations in 1 Week (With Heavy AI Assistance)

#python #ai #buildinpublic #showdev

The Problem

I had hundreds of AI conversations with Claude and ChatGPT. Valuable code, solutions, and insights were buried in those exports. Sure, I could grep through them with my hacky script (claude_ai_convo_dump_extractor - great name, right?), but I wanted something better.

So last week, with AI enthusiastically egging me on that this would be a "great resume project," I built ChatMine.

The Twist: AI Built It Too

Here's where it gets meta. I used Claude Code extensively to build ChatMine. Yes, AI helped me build a tool to search AI conversations. 🤖

In just one week, I went from idea to working product with:

  • 90% test coverage
  • Semantic search using FAISS
  • Automatic code extraction
  • Web interface with FastAPI
  • Full CLI with rich output

What ChatMine Actually Does

My old approach:

# Dump conversations to text files
$ python claude_ai_convo_dump_extractor.py export.json
$ grep -r "async def" ./extracted/
# ... manually search through results ...
Enter fullscreen mode Exit fullscreen mode

With ChatMine:

# Import your AI conversations
$ chatmine import-claude claude-export.zip
✓ Imported 312 conversations
✓ Extracted 1,847 code snippets

# Search semantically (not just grep!)
$ chatmine search "django authentication"
Found 5 relevant conversations:
1. "Setting up Django REST auth with JWT" (March 2024)
2. "Debugging Django login issues" (February 2024)
...

# Find specific code
$ chatmine code-search "async def"
Found 23 Python async functions across your conversations

# Export to markdown for Unix tools (best of both worlds!)
$ chatmine export-conversations -o ./searchable/
$ rg "authentication" ./searchable/
Enter fullscreen mode Exit fullscreen mode

The Good, The Bad, and The Honest

The Good:

  • It actually works! Fully functional with extensive tests
  • Solves a real problem (beyond my hacky grep scripts)
  • Modern Python stack: FastAPI, SQLAlchemy, Click, FAISS
  • You can STILL grep the exports, but now with better organization

The Bad:

  • I don't fully understand some ML libraries I used (FAISS, sentence-transformers)
  • Some advanced features were "suggested" by AI that I couldn't build myself
  • Tests were sometimes written after the code (I know, I know...)

The Honest:

  • AI convinced me this was resume-worthy (it worked - I built it! 😅)
  • This is what AI-assisted development really looks like in 2025
  • You can ship impressive software fast
  • But you need to be careful about technical debt

From Hacky Scripts to Proper Tool

My original claude_ai_convo_dump_extractor was exactly what it sounds like - a script that dumped conversations so I could grep them. ChatMine evolved from that need but added:

  1. Proper data structure - SQLite instead of flat files
  2. Semantic search - Find concepts, not just keywords
  3. Code intelligence - Automatically extracts and categorizes code
  4. Better exports - Organized markdown with metadata

But honestly? Sometimes I still just want to grep things, so ChatMine can export everything to markdown files organized by date and platform. Best of both worlds!

Key Learnings from AI-Assisted Development

1. AI Accelerates, But Doesn't Replace Understanding 

# What AI generated:
def generate_embeddings(self, texts: List[str]) -> np.ndarray:
    return self.model.encode(texts, batch_size=32, show_progress_bar=True)

# What I had to understand:
# - What are embeddings?
# - Why batch_size matters?
# - How does semantic similarity work?
# (Spoiler: I'm still learning!)
Enter fullscreen mode Exit fullscreen mode

2. Tests Are Your Safety Net

With 90% test coverage, I can refactor confidently even when I don't fully understand every library:

def test_semantic_search_finds_relevant_content():
    # Even if I don't understand FAISS internals,
    # I know this behavior should work
    db = ChatMineDB(":memory:")
    db.add_conversation("Python async tutorial", "How to use async/await...")

    results = db.semantic_search("asynchronous programming")
    assert len(results) > 0
    assert "async" in results[0].content.lower()
Enter fullscreen mode Exit fullscreen mode

3. Keep Simple Options Available 

# Because sometimes you just want to grep:
@cli.command()
@click.option('--format', type=click.Choice(['rich', 'simple']), 
              default='rich', help='Export format')
def export_conversations(format):
    """Export all conversations to markdown files for Unix tools"""
    # Rich format: YAML frontmatter, metadata, topics
    # Simple format: Just the text, grep-friendly
Enter fullscreen mode Exit fullscreen mode

What's Next?

I'm open-sourcing ChatMine with a few goals:

  1. Learn from others - I need help understanding the ML libraries better
  2. Make it useful - Better than hacky scripts!
  3. Document the journey - Honest case study in AI-assisted development

The repo includes a candid README about what I built with AI help vs. what I understand deeply.

GitHub: github.com/wizzardx/chatmine

The Bigger Picture

This experiment taught me that AI-assisted development is powerful but comes with responsibilities:

  • Be honest about what you don't understand
  • Test everything thoroughly
  • Document for your future self
  • Keep simple alternatives (sometimes grep is all you need!)
  • Be ready to learn the underlying concepts

Your Turn

Have you built anything with heavy AI assistance? How do you balance speed with understanding?

Do you have hacky scripts that could become "proper" tools? (We all do!)

And if you're still grepping through AI conversation exports... well, now there's ChatMine! 🎉

Currently exploring new opportunities in Python/DevOps. Building and learning in public.

Top comments (0)