jsagir/langextract-mcp-server

✓ Python 3.8+
✓ Gemini API Key (free tier: 15 RPM, 1M tokens/day)
✓ Claude Desktop (optional)
✓ FastMCP Cloud account

# Option A: Deploy from GitHub (Recommended)
1. Go to https://fastmcp.com/dashboard
2. Sign in with GitHub
3. Click "Create New Project"
4. Select: jsagir/langextract-mcp-server
5. Configure:
   - Server File: server.py
   - Environment Variable:
     Name: LANGEXTRACT_API_KEY
     Value: [your Gemini API key]
6. Click "Deploy"
7. Copy URL: https://your-project.fastmcp.cloud

{
  "mcpServers": {
    "mindrian-langextract": {
      "url": "https://your-project.fastmcp.cloud"
    }
  }
}

# Step 1: Extract from each paper via Claude
papers = ["paper1_abstract.txt", "paper2_abstract.txt", "paper3_abstract.txt"]

for i, paper in enumerate(papers):
    print(f"Extracting from paper {i+1}...")
    # Use Claude to extract
    # result_id = extract_research_context(paper)
    # export_to_research_csv(result_id, f"paper_{i+1}.csv")

# Step 2: Combine all CSVs
import pandas as pd
import glob

csvs = glob.glob("paper_*.csv")
combined = pd.concat([pd.read_csv(f) for f in csvs], ignore_index=True)

# Step 3: Deduplicate by element_name
combined = combined.drop_duplicates(subset=['element_name', 'category'])

# Step 4: Rebuild relationship IDs
# (relationships now point to combined dataframe)

combined.to_csv("literature_review_complete.csv", index=False)

print(f"✅ Combined {len(csvs)} papers into {len(combined)} unique extractions")

import pandas as pd
import networkx as nx

# Load CSV
df = pd.read_csv('output/research_context.csv')

# Get citations
citations = df[df['category'] == 'CITATIONS_AND_REFERENCES']

# Count mentions
citation_counts = {}
for _, row in df.iterrows():
    if pd.notna(row['citation_key']):
        key = row['citation_key']
        citation_counts[key] = citation_counts.get(key, 0) + 1

# Build citation network
G = nx.DiGraph()
for _, cite in citations.iterrows():
    G.add_node(cite['citation_key'], 
               authors=cite['citation_authors'],
               year=cite['citation_year'])
    
    # Add edges based on 'related_to'
    if pd.notna(cite['related_to']):
        related = cite['related_to'].split(',')
        for r in related:
            if r in citation_counts:
                G.add_edge(cite['citation_key'], r)

# Analyze
print(f"📊 Citation Network:")
print(f"   Nodes: {G.number_of_nodes()}")
print(f"   Edges: {G.number_of_edges()}")
print(f"   Most cited: {max(citation_counts, key=citation_counts.get)}")

# Load data
df = pd.read_csv('output/research_context.csv')
constraints = df[df['category'] == 'CONSTRAINTS']

# Build dependency graph
import networkx as nx
G = nx.DiGraph()

for _, row in constraints.iterrows():
    G.add_node(row['element_name'],
               type=row['constraint_type'],
               source=row['constraint_source'],
               impact=row['impact_score'])
    
    if pd.notna(row['constraint_dependencies']):
        deps = [d.strip() for d in row['constraint_dependencies'].split(',')]
        for dep in deps:
            G.add_edge(dep, row['element_name'])

# Find critical paths
critical = [n for n in G.nodes() 
            if G.nodes[n].get('impact', 0) == '10']

print(f"⚠️ Critical Constraints: {critical}")
print(f"🔗 Dependency Network: {G.number_of_edges()} connections")

def generate_mindrian_gap_report(df):
    """Create Mindrian-style gap analysis"""
    
    report = ["# Mindrian Innovation Gap Analysis\n"]
    
    # 1. Problems Identified
    problems = df[df['subcategory'] == 'failure_modes']
    report.append("## 🔴 Critical Problems\n")
    for _, p in problems.iterrows():
        report.append(f"### {p['element_name']}")
        report.append(f"**Impact Score:** {p['impact_score']}/10")
        report.append(f"**Context:** {p['source_context']}\n")
    
    # 2. Current Gaps
    gaps = df[df['subcategory'] == 'gap_analysis']
    report.append("## 📊 Identified Gaps\n")
    for _, g in gaps.iterrows():
        report.append(f"- **{g['element_name']}**: {g['attribute_value']}")
    
    # 3. Requirements for Solution
    requirements = df[df['category'] == 'REQUIREMENTS']
    report.append("\n## ✅ Solution Requirements\n")
    for _, r in requirements.iterrows():
        report.append(f"- {r['element_name']}: {r['attribute_value']}")
    
    # 4. Critical Constraints
    constraints = df[
        (df['category'] == 'CONSTRAINTS') &
        (df['impact_score'].astype(str) == '10')
    ]
    report.append("\n## ⚠️ Hard Constraints\n")
    for _, c in constraints.iterrows():
        report.append(f"- **{c['element_name']}** ({c['constraint_type']})")
        report.append(f"  - Value: {c['attribute_value']}")
        report.append(f"  - Source: {c['constraint_source']}")
    
    # 5. Innovation Opportunities
    solutions = df[df['category'] == 'SOLUTION_SPACE']
    if not solutions.empty:
        report.append("\n## 💡 Opportunity Spaces\n")
        for _, s in solutions.iterrows():
            report.append(f"- {s['element_name']}: {s['source_context']}")
    
    return '\n'.join(report)

# Generate report
report = generate_mindrian_gap_report(df)
with open('mindrian_gap_analysis.md', 'w') as f:
    f.write(report)

print("✅ Mindrian gap analysis saved!")

from neo4j import GraphDatabase
import pandas as pd

# Load CSV
df = pd.read_csv('output/research_context.csv')

# Connect to Neo4j
driver = GraphDatabase.driver("neo4j://localhost:7687", 
                              auth=("neo4j", "password"))

def create_knowledge_graph(tx, df):
    # Create nodes
    for _, row in df.iterrows():
        tx.run("""
            CREATE (n:Entity {
                id: $id,
                name: $name,
                category: $category,
                context: $context
            })
        """, id=row['id'], 
             name=row['element_name'],
             category=row['category'],
             context=row['source_context'])
    
    # Create relationships
    for _, row in df.iterrows():
        if pd.notna(row['relationship_target']):
            targets = row['relationship_target'].split(',')
            for target in targets:
                tx.run("""
                    MATCH (a {id: $source_id})
                    MATCH (b {id: $target_id})
                    CREATE (a)-[:RELATES_TO {
                        type: $rel_type
                    }]->(b)
                """, source_id=row['id'],
                     target_id=int(target),
                     rel_type=row['relationship_type'] or 'RELATES_TO')

with driver.session() as session:
    session.write_transaction(create_knowledge_graph, df)

print("✅ Knowledge graph created in Neo4j!")

def export_bibtex(df, output_file='references.bib'):
    """Export citations to BibTeX format"""
    
    citations = df[df['category'] == 'CITATIONS_AND_REFERENCES']
    entries = []
    
    for _, cite in citations.iterrows():
        if cite['citation_type'] == 'journal_article':
            entry = f"""@article{{{cite['citation_key']},
    author = {{{cite['citation_authors'].replace(',', ' and ')}}},
    year = {{{cite['citation_year']}}},
    title = {{{cite['element_name']}}},
    doi = {{{cite['citation_url'].replace('https://doi.org/', '')}}}
}}"""
            entries.append(entry)
    
    with open(output_file, 'w') as f:
        f.write('\n\n'.join(entries))
    
    print(f"✅ Exported {len(entries)} citations to {output_file}")

export_bibtex(df)

# Primary Research Extraction
extract_research_context(
    text: str,
    model_id: str = "gemini-2.5-pro",
    extraction_passes: int = 5,
    max_workers: int = 30,
    api_key: Optional[str] = None
) -> Dict[str, Any]

# CSV Export
export_to_research_csv(
    result_id: str,
    output_name: str = "research_context.csv"
) -> Dict[str, Any]

# Get Examples
get_research_examples() -> Dict[str, Any]

# General Extraction
extract_structured_data(
    text: str,
    prompt_description: str,
    examples: List[Dict[str, Any]],
    model_id: str = "gemini-2.5-flash",
    extraction_passes: int = 1,
    max_workers: int = 10,
    max_char_buffer: int = 8000,
    api_key: Optional[str] = None
) -> Dict[str, Any]

# URL Extraction
extract_from_url(
    url: str,
    prompt_description: str,
    examples: List[Dict[str, Any]],
    model_id: str = "gemini-2.5-flash",
    extraction_passes: int = 2,
    max_workers: int = 20
) -> Dict[str, Any]

# Result Management
list_stored_results() -> Dict[str, Any]
get_extraction_details(result_id: str) -> Dict[str, Any]

# Utilities
save_results_to_jsonl(
    result_id: str,
    output_name: str = "extraction_results.jsonl"
) -> Dict[str, Any]

generate_visualization(
    result_id: str,
    output_name: str = "visualization.html"
) -> Dict[str, Any]

create_example_template(
    extraction_classes: List[str]
) -> Dict[str, Any]

get_supported_models() -> Dict[str, Any]

@software{mindrian_langextract_2025,
  title={Mindrian LangExtract MCP: Research Context Extraction},
  author={Mindrian Team},
  year={2025},
  url={https://github.com/jsagir/langextract-mcp-server}
}