# Clone the repository
git clone https://github.com/your-username/postgres-neo4j-mcp.git
cd postgres-neo4j-mcp

# Install dependencies
pip install -r requirements.txt

# Set up environment variables
cp .env.example .env
# Edit .env with your database credentials

# Run the ETL pipeline
python src/etl_pipeline.py

# Start the MCP server
python src/mcp_server.py

# Test the setup
python src/test_mcp_client.py

structured_content
├── id (PRIMARY KEY)
├── domain (VARCHAR)
├── url (TEXT, UNIQUE)
├── title (TEXT)
├── content (TEXT)
├── author (VARCHAR)
├── published_date (TIMESTAMP)
├── category (VARCHAR)
├── tags (TEXT[])
├── entities (JSONB)
├── metadata (JSONB)
└── scraped_at (TIMESTAMP)

Nodes:
├── Article (url, title, content, author, published_date, category)
├── Person (name)
├── Organization (name)
├── Topic (name)
└── Domain (name, type)

Relationships:
├── PUBLISHED_ON (Article → Domain)
├── MENTIONS_PERSON (Article → Person)
├── MENTIONS_ORGANIZATION (Article → Organization)
├── TAGGED_WITH (Article → Topic)
├── RELATED_TO (Article → Article)
└── SIMILAR_TO (Article → Article)

git clone https://github.com/your-username/postgres-neo4j-mcp.git
cd postgres-neo4j-mcp

# Create virtual environment
python -m venv venv

# Activate virtual environment
# On macOS/Linux:
source venv/bin/activate
# On Windows:
venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Create database
createdb content_scraper

# Run schema creation script
psql -U postgres -d content_scraper -f sql/create_schema.sql

# Copy example environment file
cp .env.example .env

# Edit .env with your credentials
nano .env

# PostgreSQL Configuration
PG_HOST=localhost
PG_PORT=5432
PG_DATABASE=content_scraper
PG_USER=postgres
PG_PASSWORD=your_postgres_password

# Neo4j Configuration
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=your_neo4j_password
NEO4J_DATABASE=neo4j

# MCP Server Configuration
MCP_SERVER_PORT=8080

# Optional: LLM Integration
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key

{
  "mcpServers": {
    "local-neo4j": {
      "command": "uvx",
      "args": ["mcp-neo4j-cypher@0.3.0"],
      "env": {
        "NEO4J_URI": "bolt://localhost:7687",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "your_password",
        "NEO4J_DATABASE": "neo4j",
        "NEO4J_NAMESPACE": "local"
      }
    }
  }
}

# Run with default settings
python src/etl_pipeline.py

# Run with specific parameters
python src/etl_pipeline.py \
  --pg-password your_password \
  --neo4j-password your_password \
  --limit 100  # Process only 100 records

# Start the server
python src/mcp_server.py

# The server will be available at http://localhost:8080

# Run automated tests
python src/test_mcp_client.py

# Interactive mode
python src/test_mcp_client.py interactive

# In interactive mode:
mcp> nl: show me all articles about AI
mcp> nl: find organizations mentioned in multiple domains
mcp> nl: count total number of nodes

mcp> cypher: MATCH (a:Article)-[:TAGGED_WITH]->(t:Topic {name: 'AI'}) RETURN a.title
mcp> cypher: MATCH (p:Person)<-[:MENTIONS_PERSON]-(a:Article) RETURN p.name, count(a) as mentions

GET /health

{
  "status": "healthy",
  "service": "neo4j-mcp-server"
}

GET /schema

POST /execute
Content-Type: application/json

{
  "query": "MATCH (n) RETURN count(n)",
  "type": "cypher",
  "parameters": {}
}

POST /execute
Content-Type: application/json

{
  "query": "show me all articles about AI",
  "type": "natural"
}

# Build and start all services
docker-compose up -d

# View logs
docker-compose logs -f

# Stop services
docker-compose down

# Build the MCP server image
docker build -t neo4j-mcp-server .

# Run the container
docker run -d \
  -p 8080:8080 \
  --env-file .env \
  --name mcp-server \
  neo4j-mcp-server

# Run all tests
pytest tests/

# Run specific test file
pytest tests/test_etl.py

# Run with coverage
pytest --cov=src tests/

MATCH (o:Organization)<-[:MENTIONS_ORGANIZATION]-(a:Article)
WITH o, collect(DISTINCT a.domain) as domains
WHERE size(domains) > 1
RETURN o.name, domains

MATCH (a1:Article)-[:TAGGED_WITH]->(t:Topic)<-[:TAGGED_WITH]-(a2:Article)
WHERE id(a1) < id(a2)
WITH a1, a2, collect(t.name) as shared_topics, count(t) as similarity
WHERE similarity >= 2
RETURN a1.title, a2.title, similarity
ORDER BY similarity DESC

MATCH (a:Article)
WHERE a.published_date > datetime() - duration('P30D')
RETURN a.domain, count(a) as article_count
ORDER BY article_count DESC