langsmith-cli 0.1.3__py3-none-any.whl

langsmith_cli/commands/auth.py

@@ -0,0 +1,29 @@
+import click
+import os
+import webbrowser
+from rich.console import Console
+
+console = Console()
+
+
+@click.command()
+def login():
+    """
+    Configure LangSmith API Key.
+    """
+    url = "https://smith.langchain.com/settings"
+    click.echo(f"Opening LangSmith settings to retrieve your API Key: {url}")
+    webbrowser.open(url)
+    api_key = click.prompt("Enter your LangSmith API Key", hide_input=True)
+
+    env_file = ".env"
+
+    if os.path.exists(env_file):
+        if not click.confirm(f"{env_file} already exists. Overwrite?", default=False):
+            console.print("[yellow]Aborted.[/yellow]")
+            return
+
+    with open(env_file, "w") as f:
+        f.write(f"LANGSMITH_API_KEY={api_key}\n")
+
+    console.print(f"[green]Successfully logged in![/green] API key saved to {env_file}")

langsmith_cli/commands/datasets.py

@@ -0,0 +1,170 @@
+import click
+from rich.console import Console
+from rich.table import Table
+import langsmith
+import json
+import os
+from langsmith_cli.utils import (
+    print_empty_result_message,
+    parse_json_string,
+    parse_comma_separated_list,
+)
+
+console = Console()
+
+
+@click.group()
+def datasets():
+    """Manage LangSmith datasets."""
+    pass
+
+
+@datasets.command("list")
+@click.option("--dataset-ids", help="Specific dataset IDs (comma-separated).")
+@click.option("--limit", default=20, help="Limit number of datasets (default 20).")
+@click.option("--data-type", help="Filter by dataset type (kv, chat, llm).")
+@click.option("--name", "dataset_name", help="Exact dataset name match.")
+@click.option("--name-contains", help="Dataset name substring search.")
+@click.option("--metadata", help="Filter by metadata (JSON string).")
+@click.pass_context
+def list_datasets(
+    ctx, dataset_ids, limit, data_type, dataset_name, name_contains, metadata
+):
+    """List all available datasets."""
+    client = langsmith.Client()
+
+    # Parse comma-separated dataset IDs
+    dataset_ids_list = parse_comma_separated_list(dataset_ids)
+
+    # Parse metadata JSON
+    metadata_dict = parse_json_string(metadata, "metadata")
+
+    datasets_gen = client.list_datasets(
+        dataset_ids=dataset_ids_list
+        if dataset_ids_list is None
+        else list(dataset_ids_list),  # type: ignore[arg-type]
+        limit=limit,
+        data_type=data_type,
+        dataset_name=dataset_name,
+        dataset_name_contains=name_contains,
+        metadata=metadata_dict,
+    )
+    datasets_list = list(datasets_gen)
+
+    if ctx.obj.get("json"):
+        # Use SDK's Pydantic models with focused field selection for context efficiency
+        data = [
+            d.model_dump(
+                include={
+                    "id",
+                    "name",
+                    "inputs_schema",
+                    "outputs_schema",
+                    "description",
+                    "data_type",
+                    "example_count",
+                    "session_count",
+                    "created_at",
+                    "modified_at",
+                    "last_session_start_time",
+                },
+                mode="json",
+            )
+            for d in datasets_list
+        ]
+        click.echo(json.dumps(data, default=str))
+        return
+
+    table = Table(title="Datasets")
+    table.add_column("Name", style="cyan")
+    table.add_column("ID", style="dim")
+    table.add_column("Type")
+
+    for d in datasets_list:
+        table.add_row(
+            d.name,
+            str(d.id),
+            d.data_type,
+        )
+
+    if not datasets_list:
+        print_empty_result_message(console, "datasets")
+    else:
+        console.print(table)
+
+
+@datasets.command("get")
+@click.argument("dataset_id")
+@click.pass_context
+def get_dataset(ctx, dataset_id):
+    """Fetch details of a single dataset."""
+    client = langsmith.Client()
+    dataset = client.read_dataset(dataset_id=dataset_id)
+
+    data = dataset.dict() if hasattr(dataset, "dict") else dict(dataset)
+
+    if ctx.obj.get("json"):
+        click.echo(json.dumps(data, default=str))
+        return
+
+    console.print(f"[bold]Name:[/bold] {data.get('name')}")
+    console.print(f"[bold]ID:[/bold] {data.get('id')}")
+    console.print(f"[bold]Description:[/bold] {data.get('description')}")
+
+
+@datasets.command("create")
+@click.argument("name")
+@click.option("--description", help="Dataset description.")
+@click.option(
+    "--type", "dataset_type", default="kv", help="Dataset type (kv, chat, etc.)"
+)
+@click.pass_context
+def create_dataset(ctx, name, description, dataset_type):
+    """Create a new dataset."""
+    client = langsmith.Client()
+    dataset = client.create_dataset(
+        dataset_name=name, description=description, data_type=dataset_type
+    )
+
+    if ctx.obj.get("json"):
+        data = dataset.dict() if hasattr(dataset, "dict") else dict(dataset)
+        click.echo(json.dumps(data, default=str))
+        return
+
+    console.print(f"[green]Created dataset {dataset.name}[/green] (ID: {dataset.id})")
+
+
+@datasets.command("push")
+@click.argument("file_path", type=click.Path(exists=True))
+@click.option("--dataset", help="Dataset name to push to. Created if not exists.")
+@click.pass_context
+def push_dataset(ctx, file_path, dataset):
+    """Upload examples from a JSONL file to a dataset."""
+    client = langsmith.Client()
+
+    if not dataset:
+        dataset = os.path.basename(file_path).split(".")[0]
+
+    # Create dataset if not exists (simple check)
+    try:
+        client.read_dataset(dataset_name=dataset)
+    except Exception:
+        console.print(f"[yellow]Dataset '{dataset}' not found. Creating it...[/yellow]")
+        client.create_dataset(dataset_name=dataset)
+
+    examples = []
+    with open(file_path, "r") as f:
+        for line in f:
+            if line.strip():
+                examples.append(json.loads(line))
+
+    # Expecting examples in [{"inputs": {...}, "outputs": {...}}, ...] format
+    client.create_examples(
+        inputs=[e.get("inputs", {}) for e in examples],
+        outputs=[e.get("outputs") for e in examples],
+        dataset_name=dataset,
+    )
+
+    console.print(
+        f"[green]Successfully pushed {len(examples)} examples to dataset '{dataset}'[/green]"
+    )

langsmith_cli/commands/examples.py

@@ -0,0 +1,170 @@
+import click
+from rich.console import Console
+from rich.table import Table
+import langsmith
+import json
+from langsmith_cli.utils import (
+    print_empty_result_message,
+    parse_json_string,
+    parse_comma_separated_list,
+)
+
+console = Console()
+
+
+@click.group()
+def examples():
+    """Manage dataset examples."""
+    pass
+
+
+@examples.command("list")
+@click.option("--dataset", help="Dataset ID or Name.")
+@click.option("--example-ids", help="Specific example IDs (comma-separated).")
+@click.option("--limit", default=20, help="Limit number of examples (default 20).")
+@click.option("--offset", default=0, help="Number of examples to skip (pagination).")
+@click.option("--filter", "filter_", help="LangSmith query filter.")
+@click.option("--metadata", help="Filter by metadata (JSON string).")
+@click.option("--splits", help="Filter by dataset splits (comma-separated).")
+@click.option("--inline-s3-urls", type=bool, help="Include S3 URLs inline.")
+@click.option("--include-attachments", type=bool, help="Include attachments.")
+@click.option("--as-of", help="Dataset version tag or ISO timestamp.")
+@click.pass_context
+def list_examples(
+    ctx,
+    dataset,
+    example_ids,
+    limit,
+    offset,
+    filter_,
+    metadata,
+    splits,
+    inline_s3_urls,
+    include_attachments,
+    as_of,
+):
+    """List examples for a dataset."""
+    client = langsmith.Client()
+
+    # Parse comma-separated values
+    example_ids_list = parse_comma_separated_list(example_ids)
+    splits_list = parse_comma_separated_list(splits)
+    metadata_dict = parse_json_string(metadata, "metadata")
+
+    # list_examples takes dataset_name and limit
+    examples_gen = client.list_examples(
+        dataset_name=dataset,
+        example_ids=example_ids_list,
+        limit=limit,
+        offset=offset,
+        filter=filter_,
+        metadata=metadata_dict,
+        splits=splits_list,
+        inline_s3_urls=inline_s3_urls,
+        include_attachments=include_attachments,
+        as_of=as_of,
+    )
+    examples_list = list(examples_gen)
+
+    if ctx.obj.get("json"):
+        # Use SDK's Pydantic models with focused field selection for context efficiency
+        data = [
+            e.model_dump(
+                include={
+                    "id",
+                    "inputs",
+                    "outputs",
+                    "metadata",
+                    "dataset_id",
+                    "created_at",
+                    "modified_at",
+                },
+                mode="json",
+            )
+            for e in examples_list
+        ]
+        click.echo(json.dumps(data, default=str))
+        return
+
+    table = Table(title=f"Examples: {dataset}")
+    table.add_column("ID", style="dim")
+    table.add_column("Inputs")
+    table.add_column("Outputs")
+
+    for e in examples_list:
+        inputs = json.dumps(e.inputs)
+        outputs = json.dumps(e.outputs)
+        # Truncate for table
+        if len(inputs) > 50:
+            inputs = inputs[:47] + "..."
+        if len(outputs) > 50:
+            outputs = outputs[:47] + "..."
+
+        table.add_row(str(e.id), inputs, outputs)
+
+    if not examples_list:
+        print_empty_result_message(console, "examples")
+    else:
+        console.print(table)
+
+
+@examples.command("get")
+@click.argument("example_id")
+@click.option("--as-of", help="Dataset version tag or ISO timestamp.")
+@click.pass_context
+def get_example(ctx, example_id, as_of):
+    """Fetch details of a single example."""
+    client = langsmith.Client()
+    example = client.read_example(example_id, as_of=as_of)
+
+    data = example.dict() if hasattr(example, "dict") else dict(example)
+
+    if ctx.obj.get("json"):
+        click.echo(json.dumps(data, default=str))
+        return
+
+    from rich.syntax import Syntax
+
+    console.print(f"[bold]Example ID:[/bold] {data.get('id')}")
+    console.print("\n[bold]Inputs:[/bold]")
+    console.print(Syntax(json.dumps(data.get("inputs"), indent=2), "json"))
+    console.print("\n[bold]Outputs:[/bold]")
+    console.print(Syntax(json.dumps(data.get("outputs"), indent=2), "json"))
+
+
+@examples.command("create")
+@click.option("--dataset", required=True, help="Dataset ID or Name.")
+@click.option("--inputs", required=True, help="JSON string of inputs.")
+@click.option("--outputs", help="JSON string of outputs.")
+@click.option("--metadata", help="JSON string of metadata.")
+@click.option("--split", help="Dataset split (e.g., train, test, validation).")
+@click.pass_context
+def create_example(ctx, dataset, inputs, outputs, metadata, split):
+    """Create a new example in a dataset."""
+    client = langsmith.Client()
+
+    input_dict = parse_json_string(inputs, "inputs")
+    output_dict = parse_json_string(outputs, "outputs")
+    metadata_dict = parse_json_string(metadata, "metadata")
+
+    # Handle split - can be a single string or list
+    split_value = None
+    if split:
+        split_value = [split] if isinstance(split, str) else split
+
+    example = client.create_example(
+        inputs=input_dict,
+        outputs=output_dict,
+        dataset_name=dataset,
+        metadata=metadata_dict,
+        split=split_value,
+    )
+
+    if ctx.obj.get("json"):
+        data = example.dict() if hasattr(example, "dict") else dict(example)
+        click.echo(json.dumps(data, default=str))
+        return
+
+    console.print(
+        f"[green]Created example[/green] (ID: {example.id}) in dataset {dataset}"
+    )

langsmith_cli/commands/projects.py

@@ -0,0 +1,162 @@
+import click
+from rich.console import Console
+from rich.table import Table
+import langsmith
+import json
+from langsmith_cli.utils import (
+    output_formatted_data,
+    sort_items,
+    apply_regex_filter,
+    apply_wildcard_filter,
+    determine_output_format,
+)
+
+console = Console()
+
+
+@click.group()
+def projects():
+    """Manage LangSmith projects."""
+    pass
+
+
+@projects.command("list")
+@click.option("--limit", default=100, help="Limit number of projects (default 100).")
+@click.option("--name", "name_", help="Filter by project name substring.")
+@click.option("--name-pattern", help="Filter by name with wildcards (e.g. '*prod*').")
+@click.option(
+    "--name-regex", help="Filter by name with regex (e.g. '^prod-.*-v[0-9]+$')."
+)
+@click.option(
+    "--reference-dataset-id", help="Filter experiments for a dataset (by ID)."
+)
+@click.option(
+    "--reference-dataset-name", help="Filter experiments for a dataset (by name)."
+)
+@click.option(
+    "--has-runs", is_flag=True, help="Show only projects with runs (run_count > 0)."
+)
+@click.option(
+    "--sort-by", help="Sort by field (name, run_count). Prefix with - for descending."
+)
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["table", "json", "csv", "yaml"]),
+    help="Output format (default: table, or json if --json flag used).",
+)
+@click.pass_context
+def list_projects(
+    ctx,
+    limit,
+    name_,
+    name_pattern,
+    name_regex,
+    reference_dataset_id,
+    reference_dataset_name,
+    has_runs,
+    sort_by,
+    output_format,
+):
+    """List all projects."""
+
+    client = langsmith.Client()
+
+    # Use name_ (SDK substring filter) if provided and no pattern/regex
+    # Use name_pattern as a fallback to name_ if neither are specific filters
+    api_name_filter = name_
+    if name_pattern and not name_:
+        # Extract search term from wildcard pattern for API filtering
+        search_term = name_pattern.replace("*", "")
+        if search_term:
+            api_name_filter = search_term
+
+    # list_projects returns a generator
+    projects_gen = client.list_projects(
+        limit=limit,
+        name=api_name_filter,
+        reference_dataset_id=reference_dataset_id,
+        reference_dataset_name=reference_dataset_name,
+    )
+
+    # Materialize the list to count and process
+    projects_list = list(projects_gen)
+
+    # Client-side pattern matching (wildcards)
+    projects_list = apply_wildcard_filter(projects_list, name_pattern, lambda p: p.name)
+
+    # Client-side regex filtering
+    projects_list = apply_regex_filter(projects_list, name_regex, lambda p: p.name)
+
+    # Filter by projects with runs
+    if has_runs:
+        projects_list = [
+            p
+            for p in projects_list
+            if hasattr(p, "run_count") and p.run_count and p.run_count > 0
+        ]
+
+    # Client-side sorting for table output
+    if sort_by and not ctx.obj.get("json"):
+        # Map sort field to project attribute
+        sort_key_map = {
+            "name": lambda p: (p.name or "").lower(),
+            "run_count": lambda p: p.run_count
+            if hasattr(p, "run_count") and p.run_count
+            else 0,
+        }
+        projects_list = sort_items(projects_list, sort_by, sort_key_map, console)
+
+    # Determine output format
+    format_type = determine_output_format(output_format, ctx.obj.get("json"))
+
+    # Handle non-table formats
+    if format_type != "table":
+        # Use SDK's Pydantic models with focused field selection for context efficiency
+        data = [
+            p.model_dump(
+                include={"name", "id"},
+                mode="json",
+            )
+            for p in projects_list
+        ]
+        output_formatted_data(data, format_type)
+        return
+
+    table = Table(title="Projects")
+    table.add_column("Name", style="cyan")
+    table.add_column("ID", style="dim")
+
+    for p in projects_list:
+        # Access attributes directly (type-safe)
+        table.add_row(p.name, str(p.id))
+
+    if not projects_list:
+        console.print("[yellow]No projects found.[/yellow]")
+    else:
+        console.print(table)
+
+
+@projects.command("create")
+@click.argument("name")
+@click.option("--description", help="Project description.")
+@click.pass_context
+def create_project(ctx, name, description):
+    """Create a new project."""
+    from langsmith.utils import LangSmithConflictError
+
+    client = langsmith.Client()
+    try:
+        project = client.create_project(project_name=name, description=description)
+        if ctx.obj.get("json"):
+            # Use SDK's Pydantic model directly
+            data = project.model_dump(mode="json")
+            click.echo(json.dumps(data, default=str))
+            return
+
+        console.print(
+            f"[green]Created project {project.name}[/green] (ID: {project.id})"
+        )
+    except LangSmithConflictError:
+        # Project already exists - handle gracefully for idempotency
+        console.print(f"[yellow]Project {name} already exists.[/yellow]")

langsmith_cli/commands/prompts.py

@@ -0,0 +1,125 @@
+import click
+from rich.console import Console
+from rich.table import Table
+import langsmith
+import json
+from langsmith_cli.utils import (
+    print_empty_result_message,
+    parse_comma_separated_list,
+)
+
+console = Console()
+
+
+@click.group()
+def prompts():
+    """Manage LangSmith prompts."""
+    pass
+
+
+@prompts.command("list")
+@click.option("--limit", default=20, help="Limit number of prompts (default 20).")
+@click.option(
+    "--is-public", type=bool, default=None, help="Filter by public/private status."
+)
+@click.pass_context
+def list_prompts(ctx, limit, is_public):
+    """List available prompt repositories."""
+    client = langsmith.Client()
+    # list_prompts returns ListPromptsResponse with .repos attribute
+    result = client.list_prompts(limit=limit, is_public=is_public)
+    prompts_list = result.repos
+
+    if ctx.obj.get("json"):
+        # Use SDK's Pydantic models with focused field selection for context efficiency
+        data = [
+            p.model_dump(
+                include={
+                    "repo_handle",
+                    "description",
+                    "id",
+                    "is_public",
+                    "tags",
+                    "owner",
+                    "full_name",
+                    "num_likes",
+                    "num_downloads",
+                    "num_views",
+                    "created_at",
+                    "updated_at",
+                },
+                mode="json",
+            )
+            for p in prompts_list
+        ]
+        click.echo(json.dumps(data, default=str))
+        return
+
+    table = Table(title="Prompts")
+    table.add_column("Repo", style="cyan")
+    table.add_column("Description")
+    table.add_column("Owner", style="dim")
+
+    for p in prompts_list:
+        table.add_row(p.full_name, p.description or "", p.owner)
+
+    if not prompts_list:
+        print_empty_result_message(console, "prompts")
+    else:
+        console.print(table)
+
+
+@prompts.command("get")
+@click.argument("name")
+@click.option("--commit", help="Commit hash or tag.")
+@click.pass_context
+def get_prompt(ctx, name, commit):
+    """Fetch a prompt template."""
+    client = langsmith.Client()
+    # pull_prompt returns the prompt object (might be LangChain PromptTemplate)
+    prompt_obj = client.pull_prompt(name + (f":{commit}" if commit else ""))
+
+    # We want a context-efficient representation, usually the template string
+    # Try to convert to dict or extract template
+    if hasattr(prompt_obj, "to_json"):
+        data = prompt_obj.to_json()
+    else:
+        # Fallback to string representation if it's not JSON serializable trivially
+        data = {"prompt": str(prompt_obj)}
+
+    if ctx.obj.get("json"):
+        click.echo(json.dumps(data, default=str))
+        return
+
+    console.print(f"[bold]Prompt:[/bold] {name}")
+    console.print("-" * 20)
+    console.print(str(prompt_obj))
+
+
+@prompts.command("push")
+@click.argument("name")
+@click.argument("file_path", type=click.Path(exists=True))
+@click.option("--description", help="Prompt description.")
+@click.option("--tags", help="Comma-separated tags.")
+@click.option("--is-public", type=bool, default=False, help="Make prompt public.")
+@click.pass_context
+def push_prompt(ctx, name, file_path, description, tags, is_public):
+    """Push a local prompt file to LangSmith."""
+    client = langsmith.Client()
+
+    with open(file_path, "r") as f:
+        content = f.read()
+
+    # Parse tags if provided
+    tags_list = parse_comma_separated_list(tags)
+
+    # Push prompt with metadata
+    client.push_prompt(
+        prompt_identifier=name,
+        object=content,
+        description=description,
+        tags=tags_list,
+        is_public=is_public,
+    )
+
+    console.print(f"[green]Successfully pushed prompt to {name}[/green]")