Forem: Pieces.app

How to Build an Agentic Blog Generator

Pieces 🌟 — Tue, 03 Feb 2026 15:22:20 +0000

Building an Agentic Blog Generator With Pieces OS (Flutter)

This project is a Flutter app that generates a technical blog (in Markdown) from real, recent context. The core idea is simple: use Pieces OS as the source of truth for what you’ve been working on (workstream summaries + your own annotations/persona signals), then use an LLM to turn that into a structured, high-quality blog—optionally in agentic mode with MCP tools.

Features

Auto generate title: suggests blog titles from recent Pieces workstream summaries.

Detect persona: pulls recent Pieces user annotations and converts them into “persona signals” for voice/tone

Detect style: analyzes a sample blog to infer a reusable style object for consistent output.

Generate multi part blog: plans part titles + per-part outlines, then generates Markdown one part at a time.

Agentic flow: connects to the MCP endpoint and uses tools for retrieval/verification (RAG) instead of guessing.

What Pieces OS gives us (and why it matters)

When you ask an LLM to “write a blog about my project”, you usually get one of two outcomes:

A generic post that sounds plausible but doesn’t match what you actually did.
A post that misses the details that made the work interesting (trade-offs, decisions, workflow).

Pieces OS helps fix this by providing grounded context:

Workstream Summaries (LTM): a stream of recent summaries of your work so we can generate content from what actually happened recently.
Annotations (persona + preferences + voice cues): your own notes/annotations can be pulled and turned into “persona signals” so the blog tone and framing match you.
MCP (Model Context Protocol) tools: in agentic mode, the generator can call MCP tools (memory/search/context) instead of guessing—so it can fetch or verify information as it writes. Practically, connecting via the MCP endpoint gives us RAG (retrieval‑augmented generation): the model retrieves relevant context from Pieces and then writes with that grounded input.

In this app, Pieces is not a “nice-to-have integration”—it’s the backbone for relevance and personalization.

How this app uses Pieces OS

At a high level, the wizard does three Pieces-backed things:

Connect to Pieces OS
- Establishes app connection with Pieces OS (so API calls work).
Pull recent context
- Pulls recent workstream summary IDs over a short-lived WebSocket.
- Fetches each summary snapshot.
- Extracts the human-readable “DESCRIPTION” annotation text from each summary.
Pull persona signals
- Fetches recent user annotations via UserApi.userGetAnnotations().
- Normalizes/truncates them into a prompt-friendly “persona signals” block.

Then, when we run in agentic mode, we also:

Connect to the Pieces MCP endpoint
List the available tools
Allow the LLM to call those tools while planning/writing

This combination (summaries + persona + MCP tools) gives the generator a much better shot at producing content that matches reality.

Agentic mode: how we got better output (one-shot → plan-first → structured parts)

We saw a clear quality jump as we changed the prompting approach.

Attempt 1: one prompt to generate the whole blog

The naive approach is: “Here’s some context—write the entire blog.”

In practice, that tends to produce:

weak structure (rambling, repetitive sections)
missing coverage (important modules not mentioned)
brittle accuracy (model fills gaps by guessing)

Attempt 2: plan first, then generate

Next improvement: separate planning from writing.

Instead of writing immediately, we made the app generate a plan first (what parts, what each part is about). That makes the writing phase far more constrained and coherent:

the model knows the “shape” of the blog before it writes
you can review/edit titles before any heavy generation happens

Attempt 3: even more planning, broken into titled parts

The biggest jump came from adding more structure:

generate part titles first (so each part has a clear purpose)
generate an outline for each part (so headings and subheadings are defined)
then write one part at a time, using the outline as a contract

That does two things:

Focus: each part stays on-topic (because it has a title + outline).
Better coverage: parts are explicitly scoped, so important areas are less likely to be skipped.

This is exactly why titled parts matter: the model is no longer inventing structure as it writes—it’s executing a plan you’ve already approved.

Tutorial: integrating Pieces OS in a Flutter app

This section breaks down how we integrated Pieces OS in a way that works well for a UI-driven Flutter app. The goal is to make the model’s output grounded (Pieces workstream summaries + persona signals) and optionally agentic (MCP endpoint → RAG).

Step 1: configure the Pieces endpoints

In PiecesOSService, we keep the local Pieces defaults in one place:

baseUrl: REST API base (http://localhost:39300)
websocketUrl: WebSocket base (ws://localhost:39300)
defaultMcpEndpoint: MCP streamable HTTP endpoint (used for tool-based RAG)

Here’s the exact code that defines those endpoints (and the imports used by the service):

import 'dart:async';
import 'dart:developer' as dev;
import 'dart:convert';
import 'dart:io';
import 'package:mcp_dart/mcp_dart.dart' as mcp;
import 'package:pieces_os_client/api.dart';

import '../models/persona_signals.dart';

/// Service to interact with Pieces OS for LTM (Long Term Memory)
class PiecesOSService {
  // Pieces OS configuration
  static const String baseUrl = 'http://localhost:39300';
  static const String websocketUrl = 'ws://localhost:39300';
  static const String defaultMcpEndpoint =
      'http://localhost:39300/model_context_protocol/2025-03-26/mcp';

Step 2: connect the app to Pieces OS (REST)

The connectApplication() method registers/connects this app with Pieces via ConnectorApi.connect(...) and stores the returned Context.

The initialize() method is a small guard that:

ensures we only connect once per session (_isInitialized)
makes all later calls safe to run “just-in-time” from the UI

Here are the service fields + constructor + REST connection code:

  // API clients
  late final ApiClient client;
  late final ConnectorApi _connectorApi;
  late final WorkstreamSummaryApi _workstreamSummaryApi;
  late final AnnotationApi _annotationApi;
  late final UserApi _userApi;

  // Application context
  Context? _context;

  // Application info
  final ApplicationNameEnum appName = ApplicationNameEnum.OPEN_SOURCE;
  final String appVersion = "0.0.1";
  final PlatformEnum platform = Platform.operatingSystem == "windows"
      ? PlatformEnum.WINDOWS
      : Platform.operatingSystem == "macos"
      ? PlatformEnum.MACOS
      : PlatformEnum.LINUX;

  // Track if service is initialized
  bool _isInitialized = false;

  /// Placeholder persona string
  /// generation prompts later.
  String persona = '';

  PiecesOSService() {
    client = ApiClient(basePath: baseUrl);
    _connectorApi = ConnectorApi(client);
    _workstreamSummaryApi = WorkstreamSummaryApi(client);
    _annotationApi = AnnotationApi(client);
    _userApi = UserApi(client);
  }

  /// Register/Connect the application to Pieces OS
  Future<Application> connectApplication() async {
    if (_context?.application != null) {
      return _context!.application;
    }

    try {
      final seededApp = SeededTrackedApplication(
        name: appName,
        platform: platform,
        version: appVersion,
      );

      final connection = SeededConnectorConnection(application: seededApp);

      _context = await _connectorApi.connect(
        seededConnectorConnection: connection,
      );

      if (_context?.application == null) {
        throw Exception(
          'Failed to connect to Pieces OS: No application returned',
        );
      }

      dev.log(
        'Successfully connected to Pieces OS: ${_context!.application.name}',
        name: 'PiecesOSService',
      );
      return _context!.application;
    } catch (e, st) {
      dev.log(
        'Error connecting to Pieces OS',
        name: 'PiecesOSService',
        error: e,
        stackTrace: st,
      );
      rethrow;
    }
  }

  /// Initialize the service - connects to Pieces OS.
  ///
  /// NOTE: We intentionally do **not** start any WebSocket listeners. This app
  /// fetches workstream summary identifiers on-demand.
  Future<void> initialize() async {
    if (_isInitialized) {
      dev.log('Service already initialized', name: 'PiecesOSService');
      return;
    }

    try {
      // Connect to Pieces OS
      await connectApplication();

      _isInitialized = true;
      dev.log('Initialized successfully', name: 'PiecesOSService');
    } catch (e, st) {
      dev.log(
        'Error initializing',
        name: 'PiecesOSService',
        error: e,
        stackTrace: st,
      );
      rethrow;
    }
  }

Step 3: retrieve recent work context (workstream summaries)

To ground generation in “what I actually worked on”, the service does this on-demand:

fetchLatestWorkstreamSummaryIds() opens a WebSocket to the identifiers stream, reads one payload, then closes the socket.
getLastSummaryContents() uses those IDs to fetch summary snapshots and extracts the DESCRIPTION annotation text via getSummaryContent().

Those DESCRIPTION strings are what we feed into the LLM as “recent context”.

Here’s the exact code for streaming IDs, fetching summaries, and extracting DESCRIPTION text:

  /// Fetch the most recent workstream summary identifiers on-demand.
  ///
  /// This opens a WebSocket connection **once**, reads the first identifiers
  /// payload, then closes the socket. No continuous listener / no caching.
  Future<List<String>> fetchLatestWorkstreamSummaryIds({
    int limit = 10,
    Duration timeout = const Duration(seconds: 8),
  }) async {
    if (limit <= 0) return const [];
    await initialize();

    final wsUrl = '$websocketUrl/workstream_summaries/stream/identifiers';
    WebSocket? socket;
    try {
      socket = await WebSocket.connect(wsUrl).timeout(timeout);
      final first = await socket.first.timeout(timeout);

      String raw;
      if (first is String) {
        raw = first;
      } else if (first is List<int>) {
        raw = utf8.decode(first);
      } else {
        raw = first.toString();
      }

      final decoded = jsonDecode(raw);
      final streamed = StreamedIdentifiers.fromJson(decoded);
      final ids = (streamed?.iterable ?? const [])
          .map((e) => e.workstreamSummary?.id)
          .whereType<String>()
          .where((s) => s.trim().isNotEmpty)
          .take(limit)
          .toList(growable: false);
      return ids;
    } finally {
      try {
        await socket?.close();
      } catch (_) {
        // ignore
      }
    }
  }

  /// Get the summary content from a workstream summary's annotations
  Future<String?> getSummaryContent(WorkstreamSummary summary) async {
    try {
      // Loop through annotations to find the DESCRIPTION type
      for (final annotationRef
          in summary.annotations?.indices.keys.toList() ?? []) {
        // Fetch the full annotation using AnnotationApi (singular)
        final annotation = await _annotationApi
            .annotationSpecificAnnotationSnapshot(annotationRef);
        if (annotation == null) {
          continue;
        }

        // Check if this is a DESCRIPTION type annotation
        if (annotation.type == AnnotationTypeEnum.DESCRIPTION) {
          // Return the text content
          return annotation.text;
        }
      }

      return null;
    } catch (e) {
      dev.log(
        'Error fetching annotation content for ${summary.id}: $e',
        name: 'PiecesOSService',
      );
      return null;
    }
  }

  /// Get the last [limit] workstream summary DESCRIPTION texts (most recent first).
  ///
  /// This performs an on-demand identifiers fetch, then retrieves each summary
  /// snapshot and its DESCRIPTION annotation text.
  Future<List<String>> getLastSummaryContents({int limit = 10}) async {
    if (limit <= 0) return const [];
    await initialize();

    final ids = await fetchLatestWorkstreamSummaryIds(limit: limit);
    if (ids.isEmpty) return const [];

    final summaries = await Future.wait(
      ids.map(
        (id) => _workstreamSummaryApi
            .workstreamSummariesSpecificWorkstreamSummarySnapshot(id),
      ),
    );

    final contents = await Future.wait(
      summaries.whereType<WorkstreamSummary>().map(
        (s) async => (await getSummaryContent(s))?.trim(),
      ),
    );

    return contents.whereType<String>().where((t) => t.isNotEmpty).toList();
  }

Step 4: retrieve persona signals (user annotations)

To personalize voice and framing, getPersonaFromUserAnnotations():

resolves the active user (_resolveUserId() → UserApi.userSnapshot())
fetches recent annotations (UserApi.userGetAnnotations(...))
normalizes them into a prompt-friendly PersonaAnnotations object

If Pieces returns no annotations, we keep persona optional (so the model doesn’t invent one).

Here’s the code that resolves the active user and turns annotations into prompt-friendly “persona signals”:

  Future<String> _resolveUserId() async {
    await initialize();

    final snap = await _userApi.userSnapshot();
    final userId = snap?.user?.id;
    if (userId != null && userId.trim().isNotEmpty) return userId.trim();

    throw StateError(
      'No active user found. Ensure Pieces has an active user session.',
    );
  }

  /// Get a "persona" text derived from the user's annotations.
  ///
  /// Uses `UserApi.userGetAnnotations()` which returns the resolved active Person
  /// and filtered Annotations.
  Future<PersonaAnnotations> getPersonaFromUserAnnotations({
    int limit = 1,
  }) async {
    if (limit <= 0) return const PersonaAnnotations();
    final userId = await _resolveUserId();
    final out = await _userApi.userGetAnnotations(
      userId,
      UserAnnotationsInput(limit: limit),
    );

    final texts = out.annotations.iterable
        .map((a) => a.text)
        .whereType<String>()
        .map((t) => t.trim())
        .where((t) => t.isNotEmpty)
        .toList();
    dev.log(
      'Fetched ${texts.length} annotation texts for persona.',
      name: 'PiecesOSService',
    );

    // Pieces might return an empty annotations list; in that case we return empty
    // and let the caller omit persona entirely.
    if (texts.isEmpty) return const PersonaAnnotations();

    final normalized = <String>[];
    for (final t in texts) {
      final oneLine = t.replaceAll(RegExp(r'\s+'), ' ').trim();
      if (oneLine.isEmpty) continue;
      normalized.add(
        oneLine.length > 180 ? '${oneLine.substring(0, 180)}…' : oneLine,
      );
    }

    return PersonaAnnotations(annotations: normalized);
  }

Step 5: enable RAG with MCP (agentic mode)

When we connect via the MCP endpoint, the generator can do RAG (retrieval‑augmented generation):

connectMcp() connects a streamable HTTP transport (POST + SSE GET)
listTools() fetches and caches the available MCP tools
callTool() lets the agent retrieve/verify relevant context from Pieces during planning/writing

This is the “agentic” part: instead of guessing, the model can retrieve what it needs.

Here’s the MCP client code that enables tool calls (MCP endpoint → RAG):

  // MCP (Streamable HTTP/SSE) client
  mcp.McpClient? _mcpClient;
  mcp.StreamableHttpClientTransport? _mcpTransport;
  Uri? _mcpEndpoint;
  List<mcp.Tool>? _cachedMcpTools;

  bool get isMcpConnected =>
      _mcpClient != null && _mcpTransport != null;

  /// Connect to Pieces MCP endpoint using Streamable HTTP (POST + SSE GET).
  ///
  /// Default endpoint is `http://localhost:39300/mcp`.
  Future<void> connectMcp({String? endpoint}) async {
    final ep = Uri.parse((endpoint ?? defaultMcpEndpoint).trim());

    // If already connected to same endpoint, do nothing.
    if (isMcpConnected && _mcpEndpoint == ep) return;

    // Close any existing transport/client.
    await disconnectMcp();
    _mcpEndpoint = ep;

    final transport = mcp.StreamableHttpClientTransport(ep);
    final client = mcp.McpClient(
      const mcp.Implementation(name: 'blog_generator', version: '0.0.1'),
      options: const mcp.McpClientOptions(
        // Client-side capabilities are for server-initiated requests
        // (sampling, elicitation, tasks, roots). We don't need any for now.
        capabilities: mcp.ClientCapabilities(),
      ),
    );

    transport.onerror = (err) {
      dev.log(
        'MCP transport error: $err',
        name: 'PiecesOSService',
        error: err,
      );
    };
    transport.onclose = () {
      dev.log('MCP transport closed', name: 'PiecesOSService');
      _cachedMcpTools = null;
      _mcpClient = null;
      _mcpTransport = null;
    };

    try {
      await client.connect(transport);
      _mcpTransport = transport;
      _mcpClient = client;
      final server = client.getServerVersion();
      dev.log(
        'MCP connected: ${server?.name ?? 'unknown'} ${server?.version ?? ''}',
        name: 'PiecesOSService',
      );
    } catch (e) {
      await disconnectMcp();
      rethrow;
    }
  }

  Future<void> disconnectMcp() async {
    _cachedMcpTools = null;
    try {
      await _mcpTransport?.terminateSession();
    } catch (_) {
      // Ignore - server may not support.
    }

    try {
      await _mcpClient?.close();
    } catch (_) {
      // Ignore.
    }
    try {
      await _mcpTransport?.close();
    } catch (_) {
      // Ignore.
    }

    _mcpClient = null;
    _mcpTransport = null;
  }

  Future<List<mcp.Tool>> listTools({bool forceRefresh = false}) async {
    final client = _mcpClient;
    if (client == null) {
      throw StateError('MCP client not connected');
    }

    if (!forceRefresh && _cachedMcpTools != null) return _cachedMcpTools!;

    final res = await client.listTools();
    _cachedMcpTools = res.tools;
    return res.tools;
  }

  Future<mcp.CallToolResult> callTool({
    required String name,
    Map<String, dynamic> arguments = const {},
  }) async {
    final client = _mcpClient;
    if (client == null) {
      throw StateError('MCP client not connected');
    }

    return client.callTool(
      mcp.CallToolRequest(name: name, arguments: arguments),
    );
  }

Step 6: clean up

dispose() closes the MCP session (best-effort) and clears state so the service doesn’t leak resources across UI lifecycles.

Here’s the cleanup method from the service (it also closes the class):

  /// Disconnect from Pieces OS and cleanup resources
  void dispose() {
    _isInitialized = false;

    // Close MCP client/transport
    // Fire and forget; dispose is sync.
    unawaited(disconnectMcp());

    // Clear context
    _context = null;

    dev.log('Disposed', name: 'PiecesOSService');
  }
}

How the UI uses this service (quick walkthrough)

In BlogWizardScreen, the flow looks like this:

Get grounded context
- _pieces.getLastSummaryContents(limit: 10) for recent workstream summaries
- _pieces.getPersonaFromUserAnnotations(limit: 1) for persona signals (optional)
Turn on agentic RAG
- _pieces.connectMcp(...) then _pieces.listTools()
- pass callMcpTool: (...) => _pieces.callTool(...) into the agent loop

From there, the generator improves quality by moving from one-shot output to a structured workflow:

plan part titles first
generate outlines per part (reviewable)
write each part with the outline as a contract

Takeaway

Pieces OS is what makes this blog generator feel real:

it anchors generation in your actual recent work (summaries)
it shapes tone/voice via your own signals (annotations → persona)
it enables agentic correctness when available (MCP tools)

And the prompt strategy matters just as much: moving from one-shot generation to a plan-first, titled multi-part workflow is what consistently turns “okay output” into “publishable output”.

The rest of the project code (UI, models, generation logic, widgets, etc.) is available on GitHub repository.

Building a TUI with Pieces SDK - Part 3: Advanced Features

Pieces 🌟 — Mon, 02 Feb 2026 17:57:24 +0000

Building a Pieces Copilot TUI - Part 3: Advanced Features & Integration

Note: This tutorial is part of the Pieces CLI project. We welcome contributions! Feel free to open issues, submit PRs, or suggest improvements.

Introduction

Welcome to Part 3! In Part 2, we built the core UI components. Now, we'll add the advanced features to create a fully-functional Pieces Copilot TUI.

What we built in Part 2:

✅ Message widget (chat_message.py)
✅ Chat panel (chat_panel.py)
✅ Input widget (chat_input.py)
✅ Basic view (chat_view.py - simple version)
✅ Main application (app.py)

Step 1: Create the Conversations List

Let's build chats_list.py - the sidebar showing all conversations:

# chats_list.py
"""Conversations list panel widget."""

from typing import Optional
from textual.widgets import Static, Button
from textual.containers import VerticalScroll, Vertical
from textual.message import Message

from pieces_os_client import PiecesClient
from pieces_os_client.wrapper.basic_identifier.chat import BasicChat


class ChatSelected(Message):
    """Message emitted when a chat is selected."""

    def __init__(self, chat: BasicChat):
        super().__init__()
        self.chat = chat


class NewChatRequested(Message):
    """Message emitted when new chat is requested."""
    pass


class ChatItem(Static):
    """Widget representing a single chat in the list."""

    DEFAULT_CSS = """
    ChatItem {
        width: 100%;
        height: auto;
        padding: 1 2;
        margin-bottom: 1;
        background: $surface;
        border-left: solid $primary;
    }

    ChatItem:hover {
        background: $panel;
        border-left: solid $accent;
    }

    ChatItem.active {
        background: $primary 30%;
        border-left: thick $accent;
        text-style: bold;
    }

    ChatItem .chat-title {
        color: $text;
        text-style: bold;
    }

    ChatItem .chat-summary {
        color: $text-muted;
        text-style: italic;
    }
    """

    def __init__(self, chat: BasicChat, **kwargs):
        super().__init__(**kwargs)
        self.chat = chat

    def compose(self):
        """Compose the chat item."""
        title = self.chat.name or "Untitled"
        summary = self.chat.summary or ""
        if len(summary) > 50:
            summary = summary[:47] + "..."

        yield Static(f"💬 {title}", classes="chat-title")
        if summary:
            yield Static(summary, classes="chat-summary")

    def on_click(self) -> None:
        """Handle click event."""
        self.post_message(ChatSelected(self.chat))


class ChatsList(Vertical):
    """Panel to display list of conversations."""

    DEFAULT_CSS = """
    ChatsList {
        width: 25%;
        height: 100%;
        border: solid $primary;
        background: $background;
        padding: 1;
    }

    ChatsList:focus-within {
        border: solid $accent;
    }

    ChatsList Button {
        width: 100%;
        margin-bottom: 1;
    }

    ChatsList VerticalScroll {
        height: 1fr;
    }

    ChatsList .empty-state {
        text-align: center;
        color: $text-muted;
        text-style: italic;
        margin: 2;
    }
    """

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.border_title = "Conversations"
        self.active_chat: Optional[BasicChat] = None
        self._chat_items = {}

    def compose(self):
        """Compose the chats list panel."""
        yield Button("➕ New Chat", id="new-chat-btn")
        yield VerticalScroll(id="chats-container")

    def load_chats(self, pieces_client: PiecesClient):
        """Load chats from the API."""
        try:
            chats = pieces_client.copilot.chats()

            container = self.query_one("#chats-container", VerticalScroll)

            # Clear existing items
            container.remove_children()
            self._chat_items.clear()

            if not chats:
                container.mount(Static("No chats yet...", classes="empty-state"))
            else:
                for chat in chats:
                    chat_item = ChatItem(chat)
                    self._chat_items[chat.id] = chat_item
                    container.mount(chat_item)
        except (ConnectionError, AttributeError) as e:
            container = self.query_one("#chats-container", VerticalScroll)
            container.mount(Static(f"❌ Failed to load chats: {str(e)}", classes="empty-state"))

    def set_active_chat(self, chat: Optional[BasicChat]):
        """Set the active chat and update UI."""
        # Remove active class from all items
        for item in self._chat_items.values():
            item.remove_class("active")

        self.active_chat = chat

        # Add active class to the selected item
        if chat and chat.id in self._chat_items:
            self._chat_items[chat.id].add_class("active")

    def add_new_chat(self, chat: BasicChat):
        """Add a new chat to the list."""
        container = self.query_one("#chats-container", VerticalScroll)

        # Remove empty state if present
        try:
            empty_state = container.query_one(".empty-state")
            empty_state.remove()
        except LookupError:
            # No empty state widget present, which is fine
            pass

        # Add new chat at the top
        chat_item = ChatItem(chat)
        self._chat_items[chat.id] = chat_item

        # Mount at the beginning
        if container.children:
            container.mount(chat_item, before=container.children[0])
        else:
            container.mount(chat_item)

    def on_button_pressed(self, event: Button.Pressed) -> None:
        """Handle button press."""
        if event.button.id == "new-chat-btn":
            self.post_message(NewChatRequested())

Key features:

ChatItem - Individual conversation with title and summary
ChatSelected - Custom message when chat is clicked
NewChatRequested - Message when "New Chat" button is pressed
Active chat highlighting
Hover effects
Error handling for API failures

Step 2: Create the Streaming Handler

Now src/pieces_copilot_tui/streaming_handler.py - connects Pieces OS streaming to our UI:

# src/pieces_copilot_tui/streaming_handler.py
"""Handler for streaming responses from Pieces OS."""

from typing import Callable, Optional

from pieces_os_client.wrapper import PiecesClient
from pieces_os_client.wrapper.basic_identifier.chat import BasicChat


class StreamingHandler:
    """Handles streaming responses from the Pieces Copilot."""

    def __init__(
        self,
        pieces_client: PiecesClient,
        on_thinking_started: Callable[[], None],
        on_stream_started: Callable[[str], None],
        on_stream_chunk: Callable[[str], None],
        on_stream_completed: Callable[[Optional[BasicChat]], None],
        on_stream_error: Callable[[str], None],
    ):
        """
        Initialize the streaming handler.

        Args:
            pieces_client: The Pieces client instance
            on_thinking_started: Callback when thinking starts
            on_stream_started: Callback when streaming starts (with initial text)
            on_stream_chunk: Callback for each chunk (with full accumulated text)
            on_stream_completed: Callback when streaming completes (with optional new chat)
            on_stream_error: Callback when an error occurs (with error message)
        """
        self.pieces_client = pieces_client
        self.on_thinking_started = on_thinking_started
        self.on_stream_started = on_stream_started
        self.on_stream_chunk = on_stream_chunk
        self.on_stream_completed = on_stream_completed
        self.on_stream_error = on_stream_error

        self._current_response = ""
        self._current_status: Optional[str] = None

        # Register callback
        if self.pieces_client.copilot.ask_stream_ws:
            self.pieces_client.copilot.ask_stream_ws.on_message_callback = (
                self._handle_stream_message
            )

    def ask_question(self, query: str) -> None:
        """
        Ask a question to the copilot.

        Args:
            query: The question to ask
        """
        self._current_response = ""
        self._current_status = None
        self.on_thinking_started()
        self.pieces_client.copilot.stream_question(query)

    def _handle_stream_message(self, response) -> None:
        """Handle streaming messages from the copilot."""
        try:
            status = response.status

            if status == "IN-PROGRESS":
                if response.question:
                    answers = response.question.answers.iterable
                    for answer in answers:
                        if answer.text:
                            if not self._current_response:
                                # First chunk - start streaming
                                self._current_response = answer.text
                                self.on_stream_started(self._current_response)
                            else:
                                # Subsequent chunks
                                self._current_response += answer.text
                                self.on_stream_chunk(self._current_response)

            elif status == "COMPLETED":
                # Streaming completed
                new_chat = None
                if response.conversation:
                    new_chat = BasicChat(response.conversation)
                    self.pieces_client.copilot.chat = new_chat

                self.on_stream_completed(new_chat)
                self._current_response = ""

            elif status in ["FAILED", "STOPPED", "CANCELED"]:
                # Handle error
                error_msg = getattr(response, "error_message", "Unknown error")
                self.on_stream_error(error_msg)
                self._current_response = ""

        except (AttributeError, ConnectionError, ValueError) as e:
            self.on_stream_error(str(e))
            self._current_response = ""

Step 3: Create the Full View Orchestrator

Now the complete chat_view.py - replaces the simple version from Part 2:

# chat_view.py
"""Main copilot view combining all widgets."""

from typing import Optional
from textual.screen import Screen
from textual.containers import Horizontal, Vertical
from textual.binding import Binding
from textual.widgets import Footer

from pieces_os_client import PiecesClient
from pieces_os_client.wrapper.basic_identifier.chat import BasicChat

from .chat_panel import ChatPanel
from .chats_list import ChatsList, ChatSelected, NewChatRequested
from .chat_input import ChatInput, MessageSubmitted
from .streaming_handler import StreamingHandler


class CopilotView(Screen):
    """Main copilot view screen."""

    BINDINGS = [
        Binding("ctrl+n", "new_chat", "New Chat"),
        Binding("ctrl+r", "rename_chat", "Rename"),
        Binding("ctrl+d", "delete_chat", "Delete"),
        Binding("ctrl+l", "toggle_ltm", "Toggle LTM"),
        Binding("ctrl+q", "quit", "Quit"),
    ]

    DEFAULT_CSS = """
    CopilotView {
        layout: vertical;
    }

    CopilotView Horizontal {
        height: 1fr;
    }

    CopilotView Vertical.main-content {
        width: 75%;
        layout: vertical;
    }
    """

    def __init__(self, pieces_client: PiecesClient, **kwargs):
        super().__init__(**kwargs)
        self.pieces_client = pieces_client
        self.current_chat: Optional[BasicChat] = None
        self.chat_panel: Optional[ChatPanel] = None
        self.chats_list: Optional[ChatsList] = None
        self.chat_input: Optional[ChatInput] = None
        self._ltm_enabled = False
        self.streaming_handler: Optional[StreamingHandler] = None

    def compose(self):
        """Compose the view."""
        with Horizontal():
            # Left sidebar - conversations list
            self.chats_list = ChatsList()
            yield self.chats_list

            # Right side - chat panel and input
            with Vertical(classes="main-content"):
                self.chat_panel = ChatPanel()
                yield self.chat_panel

                self.chat_input = ChatInput()
                yield self.chat_input

        yield Footer()

    def on_mount(self) -> None:
        """Initialize the view."""
        # Load chats
        self.chats_list.load_chats(self.pieces_client)

        # Show welcome message
        self.chat_panel.show_welcome()

        # Check LTM status
        try:
            self._ltm_enabled = self.pieces_client.copilot.is_chat_ltm_enabled()
        except (ConnectionError, AttributeError):
            self._ltm_enabled = False

        # Setup streaming handler
        self.streaming_handler = StreamingHandler(
            pieces_client=self.pieces_client,
            on_thinking_started=self._on_thinking_started,
            on_stream_started=self._on_stream_started,
            on_stream_chunk=self._on_stream_chunk,
            on_stream_completed=self._on_stream_completed,
            on_stream_error=self._on_stream_error,
        )

    def on_chat_selected(self, message: ChatSelected) -> None:
        """Handle chat selection."""
        self.current_chat = message.chat
        self.pieces_client.copilot.chat = message.chat
        self.chats_list.set_active_chat(message.chat)

        # Load conversation
        self.chat_panel.clear_messages()
        self.chat_panel.border_title = f"Chat: {message.chat.name}"

        try:
            messages = message.chat.messages()
            for msg in messages:
                role = msg.role
                content = msg.raw_content
                self.chat_panel.add_message(role, content)
        except (ConnectionError, AttributeError, ValueError) as e:
            self.chat_panel.add_message("system", f"❌ Error loading messages: {str(e)}")

    def on_new_chat_requested(self, _: NewChatRequested) -> None:
        """Handle new chat request."""
        self.action_new_chat()

    def on_message_submitted(self, message: MessageSubmitted) -> None:
        """Handle user message submission."""
        if self.chat_panel.is_streaming_active():
            return

        # Add user message to chat panel
        self.chat_panel.add_message("user", message.text)

        # Send to copilot via streaming handler
        if self.streaming_handler:
            self.streaming_handler.ask_question(message.text)

    # Streaming handler callbacks
    def _on_thinking_started(self) -> None:
        """Called when copilot starts thinking."""
        self.call_from_thread(self.chat_panel.add_thinking_indicator)

    def _on_stream_started(self, initial_text: str) -> None:
        """Called when streaming starts with initial text."""
        self.call_from_thread(
            self.chat_panel.add_streaming_message,
            "assistant",
            initial_text
        )

    def _on_stream_chunk(self, full_text: str) -> None:
        """Called for each streaming chunk with accumulated text."""
        self.call_from_thread(
            self.chat_panel.update_streaming_message,
            full_text
        )

    def _on_stream_completed(self, new_chat: Optional[BasicChat]) -> None:
        """Called when streaming completes."""
        self.call_from_thread(self.chat_panel.finalize_streaming_message)

        # Update chat reference if new chat was created
        if new_chat:
            old_chat = self.current_chat
            if not old_chat or old_chat.id != new_chat.id:
                self.current_chat = new_chat
                self.call_from_thread(self.chats_list.add_new_chat, new_chat)
                self.call_from_thread(self.chats_list.set_active_chat, new_chat)
                self.chat_panel.border_title = f"Chat: {new_chat.name}"

    def _on_stream_error(self, error_msg: str) -> None:
        """Called when a streaming error occurs."""
        self.call_from_thread(
            self.chat_panel.add_message,
            "system",
            f"❌ Error: {error_msg}"
        )

    def action_new_chat(self):
        """Create a new chat."""
        self.current_chat = None
        self.pieces_client.copilot.chat = None
        self.chats_list.set_active_chat(None)
        self.chat_panel.clear_messages()
        self.chat_panel.border_title = "Chat: New Conversation"
        self.chat_panel.show_welcome()
        self.chat_input.focus()

    def action_rename_chat(self):
        """Rename the current chat."""
        if not self.current_chat:
            self.notify("No chat selected", severity="warning")
            return

        # For now, just show a notification - you can implement a dialog later
        self.notify("Rename chat - Not implemented yet", severity="info")

    def action_delete_chat(self):
        """Delete the current chat."""
        if not self.current_chat:
            self.notify("No chat selected", severity="warning")
            return

        try:
            chat_name = self.current_chat.name
            self.current_chat.delete()
            self.notify(f"Deleted chat: {chat_name}", severity="success")

            # Clear view and reload chats
            self.action_new_chat()
            self.chats_list.load_chats(self.pieces_client)

        except (ConnectionError, AttributeError) as e:
            self.notify(f"Error deleting chat: {str(e)}", severity="error")

    def action_toggle_ltm(self):
        """Toggle LTM (Long Term Memory)."""
        try:
            is_chat_ltm_enabled = self.pieces_client.copilot.is_chat_ltm_enabled()

            if is_chat_ltm_enabled:
                self.pieces_client.copilot.deactivate_ltm()
                self.notify("🧠 Chat LTM disabled", severity="info")
                self._ltm_enabled = False
            else:
                is_system_ltm_running = self.pieces_client.copilot.is_ltm_running()

                if is_system_ltm_running:
                    self.pieces_client.copilot.activate_ltm()
                    self.notify("🧠 Chat LTM enabled", severity="success")
                    self._ltm_enabled = True
                else:
                    self.notify("🧠 LTM system not running. Please enable it first.", severity="warning")

        except (ConnectionError, AttributeError) as e:
            self.notify(f"❌ Error toggling LTM: {str(e)}", severity="error")

🚨 Critical for Thread Safety

Always use call_from_thread() when updating UI from background threads. Direct UI updates from threads will cause crashes! The streaming handler runs in a background thread, so all UI updates must go through this method.

Key features:

Split-pane layout (25% sidebar, 75% chat)
Handles all custom messages (ChatSelected, NewChatRequested, MessageSubmitted)
Thread-safe UI updates via call_from_thread()
Keyboard shortcuts (Ctrl+N, Ctrl+D, Ctrl+L, Ctrl+Q)
Conversation management
LTM toggle support

Step 4: Update the Main Application

Now update src/pieces_copilot_tui/app.py to use the full CopilotView:

# src/pieces_copilot_tui/app.py
"""Pieces Copilot TUI - A Terminal User Interface for Pieces OS."""

from textual.app import App

from pieces_os_client.wrapper import PiecesClient
from .chat_view import CopilotView


class PiecesCopilotTUI(App):
    """Pieces Copilot TUI with full features."""

    # CSS styles for the entire app
    DEFAULT_CSS = """
    Screen {
        background: $background;
        color: $text;
    }

    .error {
        color: $error;
        text-style: bold;
    }

    .success {
        color: $success;
        text-style: bold;
    }

    .warning {
        color: $warning;
        text-style: bold;
    }
    """

    def __init__(self, pieces_client: PiecesClient = None, **kwargs):
        super().__init__(**kwargs)
        self.pieces_client = pieces_client or PiecesClient()
        self.copilot_view = None

    def on_mount(self) -> None:
        """Initialize the application."""
        self.title = "Pieces Copilot TUI"

        # Initialize Pieces client
        if not self.pieces_client.connect_websocket():
            self.notify("Failed to connect to Pieces OS", severity="error")
            self.exit()
            return

        # Create and push the full copilot view
        self.copilot_view = CopilotView(pieces_client=self.pieces_client)
        self.push_screen(self.copilot_view)


def run_tui():
    """Run the Pieces Copilot TUI application."""
    # Initialize Pieces client
    pieces_client = PiecesClient()

    # Check if Pieces OS is running
    if not pieces_client.is_pieces_running():
        print("Error: Pieces OS is not running. Please start Pieces OS first.")
        return

    app = PiecesCopilotTUI(pieces_client=pieces_client)
    app.run()


if __name__ == "__main__":
    run_tui()

Changes from Part 2:

Import CopilotView instead of SimpleChatView
Added warning CSS class
Now using the full-featured view

Step 5: Run Your Complete TUI

The __main__.py file is already set up from Part 2. Run it the Pythonic way:

# Navigate to src directory
cd src

# Run the module
python -m pieces_copilot_tui

That's it! Simple, clean, and Pythonic. ✨

🎉 You now have a fully functional Pieces Copilot TUI!

Add Debug Logging

# In any widget method
self.log(f"Current state: {some_variable}")
self.log.info("Info message")
self.log.warning("Warning message")
self.log.error("Error message")

# View in textual console

Common Issues

Problem: Streaming doesn't start

# Check WebSocket connection
if not client.copilot.ask_stream_ws:
    print("❌ WebSocket not connected!")
    client.connect_websocket()

Problem: UI not updating from streaming

# Make sure you're using call_from_thread
self.call_from_thread(self.chat_panel.add_message, "assistant", text)
# NOT: self.chat_panel.add_message("assistant", text)

Problem: Messages not loading

# Add error handling
try:
    messages = chat.messages()
except Exception as e:
    self.log.error(f"Failed to load messages: {e}")

Building a TUI with Pieces SDK - Part 2: UI Components

Pieces 🌟 — Mon, 02 Feb 2026 17:57:15 +0000

Building a Pieces Copilot TUI - Part 2: Basic UI Components

Note: This tutorial is part of the Pieces CLI project. We welcome contributions! Feel free to open issues, submit PRs, or suggest improvements.

Introduction

Welcome to Part 2! In Part 1, we learned how to use the Pieces OS SDK. Now, we'll start building the Terminal User Interface (TUI) using Textual.

What we'll build in Part 2:

Understanding Textual fundamentals
Message display widget
Chat panel for conversations
User input widget
A working basic chat interface

What we'll add in Part 3:

Conversations list sidebar
Streaming handler integration
Full view orchestration
Testing & optimization

Understanding Textual

Textual is a modern Python framework for building TUIs. It uses a reactive, component-based architecture similar to React.

Project Structure

pieces-copilot-tui/
├── venv/                                    # Virtual environment
├── requirements.txt                         # Dependencies
├── run.py                                   # Entry point
└── src/                                     # Source code
    └── pieces_copilot_tui/                  # Main package
        ├── __init__.py                      # Package initialization
        ├── app.py                           # Main TUI application
        ├── chat_message.py                  # Individual message widget (Part 2)
        ├── chat_panel.py                    # Message display panel (Part 2)
        ├── chat_input.py                    # User input widget (Part 2)
        ├── streaming_handler.py             # Pieces SDK streaming logic (Part 3)
        ├── chats_list.py                    # Conversations list (Part 3)
        └── chat_view.py                     # Main view orchestrator (Part 3)

In Part 2, we'll build the core UI components. In Part 3, we'll add conversations management and full integration.

Step 1: Create the Message Widget

Let's start with the foundation - src/pieces_copilot_tui/chat_message.py:

# src/pieces_copilot_tui/chat_message.py
"""Chat message widget for displaying individual messages."""

from datetime import datetime
from textual.widgets import Static
from textual.containers import Vertical


class ChatMessage(Vertical):
    """Widget to display a single chat message."""

    DEFAULT_CSS = """
    ChatMessage {
        width: 100%;
        height: auto;
        padding: 1 2;
        margin-bottom: 1;
    }

    ChatMessage.user-message {
        background: $primary 20%;
        border-left: thick $primary;
    }

    ChatMessage.assistant-message {
        background: $accent 20%;
        border-left: thick $accent;
    }

    ChatMessage.system-message {
        background: $warning 20%;
        border-left: thick $warning;
    }

    ChatMessage .message-header {
        color: $text-muted;
        text-style: italic;
        margin-bottom: 1;
    }

    ChatMessage .message-content {
        color: $text;
    }
    """

    def __init__(self, role: str, content: str, timestamp: str = None, **kwargs):
        super().__init__(**kwargs)
        self.role = role
        self.content = content
        self.timestamp = timestamp or datetime.now().strftime("Today %I:%M %p")

        # Set CSS class based on role
        self.add_class(f"{role}-message")

    def compose(self):
        """Compose the message widget."""
        role_emoji = {
            "user": "👤",
            "assistant": "🤖",
            "system": "⚙️"
        }
        emoji = role_emoji.get(self.role, "")

        yield Static(
            f"{emoji} {self.role.title()} - {self.timestamp}",
            classes="message-header"
        )
        yield Static(self.content, classes="message-content")

Key concepts:

Vertical container stacks children vertically
compose() defines child widgets
CSS classes are added dynamically based on message role
Emojis make it visually appealing! 🎨

CSS Variables:

$primary, $accent, $warning - Textual's built-in color variables
$text, $text-muted - Text color variables
You can customize these in your app's theme

Step 2: Create the Chat Panel

Now src/pieces_copilot_tui/chat_panel.py - the scrollable message display:

# src/pieces_copilot_tui/chat_panel.py
"""Chat panel widget for displaying conversation messages."""

from datetime import datetime
from typing import Optional
from textual.widgets import Static
from textual.containers import VerticalScroll

from .chat_message import ChatMessage


class ChatPanel(VerticalScroll):
    """Panel to display chat messages."""

    DEFAULT_CSS = """
    ChatPanel {
        width: 100%;
        height: 1fr;
        border: solid $primary;
        background: $background;
        padding: 1 2;
    }

    ChatPanel:focus {
        border: solid $accent;
    }

    ChatPanel .thinking-indicator {
        color: $warning;
        text-style: italic bold blink;
        text-align: center;
        background: $surface;
        border: dashed $warning;
        padding: 1;
        margin: 1;
    }

    ChatPanel .streaming-message {
        border-left: thick $accent;
        text-style: bold;
    }

    ChatPanel .welcome-message {
        text-align: center;
        margin: 4 2;
        padding: 3;
        border: dashed $primary;
        background: $primary 10%;
        color: $text;
        width: 100%;
        height: auto;
    }
    """

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.border_title = "Chat"
        self._messages = []
        self._thinking_widget = None
        self._streaming_widget = None

    def add_message(self, role: str, content: str, timestamp: str = None):
        """Add a new message to the chat panel."""
        self._clear_thinking_indicator()

        timestamp = timestamp or datetime.now().strftime("Today %I:%M %p")
        message = ChatMessage(role, content, timestamp)
        self._messages.append(message)
        self.mount(message)
        self.scroll_end(animate=False)

    def add_thinking_indicator(self):
        """Add a thinking indicator."""
        self._clear_thinking_indicator()
        self._thinking_widget = Static("🤔 Thinking...", classes="thinking-indicator")
        self.mount(self._thinking_widget)
        self.scroll_end(animate=False)

    def add_streaming_message(self, role: str, content: str):
        """Add a streaming message with cursor."""
        self._clear_thinking_indicator()

        timestamp = datetime.now().strftime("Today %I:%M %p")
        self._streaming_widget = ChatMessage(role, content + " ▌", timestamp)
        self._streaming_widget.add_class("streaming-message")
        self.mount(self._streaming_widget)
        self.scroll_end(animate=False)

    def update_streaming_message(self, content: str):
        """Update the streaming message content."""
        if self._streaming_widget:
            # Update the content of the last Static widget in the streaming message
            content_widget = self._streaming_widget.query(".message-content").first()
            if content_widget:
                content_widget.update(content + " ▌")
            self.scroll_end(animate=False)

    def finalize_streaming_message(self):
        """Convert streaming message to permanent message."""
        if self._streaming_widget:
            content_widget = self._streaming_widget.query(".message-content").first()
            if content_widget:
                # Remove cursor
                current_content = str(content_widget.renderable).replace(" ▌", "")
                content_widget.update(current_content)
            self._streaming_widget.remove_class("streaming-message")
            self._messages.append(self._streaming_widget)
            self._streaming_widget = None

    def clear_messages(self):
        """Clear all messages from the chat panel."""
        self._clear_thinking_indicator()
        if self._streaming_widget:
            self._streaming_widget.remove()
            self._streaming_widget = None

        for message in self._messages:
            if message.is_mounted:
                message.remove()
        self._messages.clear()

    def show_welcome(self):
        """Show welcome message."""
        welcome_text = """🎯 Pieces Copilot TUI

Type your message below to start chatting!

Press Ctrl+Q to quit."""

        welcome = Static(welcome_text, classes="welcome-message")
        self.mount(welcome)

    def _clear_thinking_indicator(self):
        """Remove thinking indicator if present."""
        if self._thinking_widget:
            if self._thinking_widget.is_mounted:
                self._thinking_widget.remove()
            self._thinking_widget = None

    def is_streaming_active(self) -> bool:
        """Check if streaming or thinking is currently active."""
        return self._streaming_widget is not None or self._thinking_widget is not None

Key features:

VerticalScroll makes it scrollable
Thinking indicator shows "🤔 Thinking..."
Streaming shows content + cursor (" ▌")
Auto-scrolls to bottom on new messages
Welcome message for first-time users

Step 3: Create the Input Widget

Simple but crucial - src/pieces_copilot_tui/chat_input.py:

# src/pieces_copilot_tui/chat_input.py
"""Chat input widget for user message entry."""

from textual.widgets import Input
from textual.message import Message


class MessageSubmitted(Message):
    """Message emitted when user submits input."""

    def __init__(self, text: str):
        super().__init__()
        self.text = text


class ChatInput(Input):
    """Input widget for chat messages."""

    DEFAULT_CSS = """
    ChatInput {
        width: 100%;
        height: 3;
        background: $surface;
        border: solid $primary;
        padding: 0 1;
        margin: 0;
        dock: bottom;
    }

    ChatInput:focus {
        border: solid $accent;
        background: $panel;
    }
    """

    def __init__(self, **kwargs):
        super().__init__(placeholder="Type your message here...", **kwargs)

    async def on_input_submitted(self, event: Input.Submitted) -> None:
        """Handle input submission."""
        if event.value.strip():
            self.post_message(MessageSubmitted(event.value.strip()))
            self.value = ""
            event.stop()

    def on_mount(self) -> None:
        """Focus the input when mounted."""
        self.focus()

Textual messages:

Custom MessageSubmitted message bubbles up to parent
Parent widgets can listen for this message
event.stop() prevents further propagation
post_message() sends the message up the widget tree

How it works:

User types message and presses Enter
on_input_submitted() is called
Creates MessageSubmitted message with the text
Parent widget receives it via on_message_submitted()
Input is cleared for next message

Step 4: Create a Simple View (For Testing)

Let's create a basic src/pieces_copilot_tui/chat_view.py to test our components:

# src/pieces_copilot_tui/chat_view.py
"""Simple chat view for testing (will be expanded in Part 3)."""

from textual.screen import Screen
from textual.containers import Vertical
from textual.binding import Binding
from textual.widgets import Footer

from pieces_os_client.wrapper import PiecesClient

from .chat_panel import ChatPanel
from .chat_input import ChatInput, MessageSubmitted


class SimpleChatView(Screen):
    """Simple chat view for testing our components."""

    BINDINGS = [
        Binding("ctrl+q", "quit", "Quit"),
    ]

    DEFAULT_CSS = """
    SimpleChatView {
        layout: vertical;
    }

    SimpleChatView Vertical {
        width: 100%;
        height: 100%;
    }
    """

    def __init__(self, pieces_client: PiecesClient, **kwargs):
        super().__init__(**kwargs)
        self.pieces_client = pieces_client
        self.chat_panel = None
        self.chat_input = None

    def compose(self):
        """Compose the view."""
        with Vertical():
                self.chat_panel = ChatPanel()
                yield self.chat_panel

                self.chat_input = ChatInput()
                yield self.chat_input

        yield Footer()

    def on_mount(self) -> None:
        """Initialize the view."""
        # Show welcome message
        self.chat_panel.show_welcome()

    def on_message_submitted(self, message: MessageSubmitted) -> None:
        """Handle user message submission."""
        # Add user message
        self.chat_panel.add_message("user", message.text)

        # Show thinking indicator
        self.chat_panel.add_thinking_indicator()

        # In Part 3, we'll connect this to the streaming handler
        # For now, just simulate a response
        self.simulate_response(message.text)

    def simulate_response(self, user_message: str):
        """Simulate a response (will be replaced with real streaming in Part 3)."""
        import asyncio

        async def add_response():
            await asyncio.sleep(1)
            self.chat_panel.add_message(
                "assistant",
                f"Echo: {user_message}\n\n(Real AI responses coming in Part 3!)"
            )

        asyncio.create_task(add_response())

💡 Note: This is a simplified version for testing. In Part 3, we'll replace simulate_response() with real streaming from Pieces OS and add the conversations list sidebar.

Step 5: Create the Main Application

Now let's create src/pieces_copilot_tui/app.py:

# src/pieces_copilot_tui/app.py
"""Pieces Copilot TUI - A Terminal User Interface for Pieces OS."""

from textual.app import App

from pieces_os_client.wrapper import PiecesClient
from .chat_view import SimpleChatView


class PiecesCopilotTUI(App):
    """Pieces Copilot TUI (Basic version for Part 2)."""

    # CSS styles for the entire app
    DEFAULT_CSS = """
    Screen {
        background: $background;
        color: $text;
    }

    .error {
        color: $error;
        text-style: bold;
    }

    .success {
        color: $success;
        text-style: bold;
    }
    """

    def __init__(self, pieces_client: PiecesClient = None, **kwargs):
        super().__init__(**kwargs)
        self.pieces_client = pieces_client or PiecesClient()
        self.chat_view = None

    def on_mount(self) -> None:
        """Initialize the application."""
        self.title = "Pieces Copilot TUI"

        # Initialize Pieces client
        if not self.pieces_client.connect_websocket():
            self.notify("Failed to connect to Pieces OS", severity="error")
            self.exit()
            return

        # Create and push the simple chat view
        self.chat_view = SimpleChatView(pieces_client=self.pieces_client)
        self.push_screen(self.chat_view)


def run_tui():
    """Run the Pieces Copilot TUI application."""
    # Initialize Pieces client
    pieces_client = PiecesClient()

    # Check if Pieces OS is running
    if not pieces_client.is_pieces_running():
        print("Error: Pieces OS is not running. Please start Pieces OS first.")
        return

    app = PiecesCopilotTUI(pieces_client=pieces_client)
    app.run()


if __name__ == "__main__":
    run_tui()

Key points:

We inject PiecesClient for better testability
CSS is used for styling (similar to web CSS!)
on_mount() is called when the app starts
Error handling for Pieces OS connection

Step 6: Create the Package Initialization

Create src/pieces_copilot_tui/__init__.py to make it a proper Python package:

# src/pieces_copilot_tui/__init__.py
"""Pieces Copilot TUI Package."""

__version__ = "0.1.0"

from .app import PiecesCopilotTUI, run_tui

__all__ = ["PiecesCopilotTUI", "run_tui"]

This allows the relative imports (.chat_message, .chat_panel, etc.) to work correctly and exports the main functions.

Step 7: Create the Module Entry Point

Create src/pieces_copilot_tui/__main__.py to make the package executable:

# src/pieces_copilot_tui/__main__.py
"""
Command-line entry point for Pieces Copilot TUI.

This allows the package to be run with: python -m pieces_copilot_tui
"""

from .app import run_tui

if __name__ == "__main__":
    run_tui()

This is the Pythonic way to make a package runnable with python -m package_name.

Step 8: Run Your Basic TUI

The cleanest way to run the TUI is from the src directory:

# Navigate to src directory
cd src

# Run the module
python -m pieces_copilot_tui

That's it! No complex setup, no PYTHONPATH manipulation, just clean Python!

What you should see:

A welcome message in the center
An input box at the bottom
You can type messages and see them displayed
Simulated responses after 1 second
Press Ctrl+Q to quit

Recap

In Part 2, we built the foundation of our TUI:

Files Created

✅ src/pieces_copilot_tui/chat_message.py - Individual message widget
✅ src/pieces_copilot_tui/chat_panel.py - Scrollable message display
✅ src/pieces_copilot_tui/chat_input.py - User input widget
✅ src/pieces_copilot_tui/chat_view.py - Simple view (basic version)
✅ src/pieces_copilot_tui/app.py - Main application
✅ src/pieces_copilot_tui/__init__.py - Package definition
✅ src/pieces_copilot_tui/__main__.py - Module entry point

What's Next in Part 3?

In Part 3: Advanced Features & Integration, we'll add:

📋 Conversations List - Sidebar showing all your chats
🌊 Real Streaming - Connect to Pieces OS for actual AI responses
🎯 Full Orchestration - Complete chat_view.py with all features
🧠 LTM Support - Long-Term Memory toggle
⚡ Advanced Features - Delete, rename, create conversations
🧪 Testing & Optimization - Make it production-ready

Preview of Part 3 components:

chats_list.py - Full conversations management
streaming_handler.py - Real-time streaming from Pieces
chat_view.py - Complete orchestrator (expanded version)
Testing, debugging, and performance tips

Troubleshooting

Textual Not Found

pip install textual>=0.47.0

UI Not Updating

# Make sure you're using self.mount() to add widgets
self.mount(message)

# Not just appending to a list

Ready for Part 3?

You now have a working TUI foundation! In Part 3, we'll transform this into a fully-featured Pieces Copilot interface with real AI streaming, conversations management, and all the bells and whistles.

Continue to Part 3 when you're ready! 🚀

Building a TUI with Pieces SDK

Pieces 🌟 — Mon, 02 Feb 2026 17:57:03 +0000

Building a Pieces Copilot TUI - Part 1: Getting Started with PiecesOS SDK

Note: This tutorial is part of the Pieces CLI. We welcome contributions! Feel free to open issues, submit PRs, or suggest improvements.

Introduction

In this two-part tutorial series, we'll build a fully functional Terminal User Interface (TUI) for Pieces Copilot from scratch. In Part 1, we'll explore the PiecesOS SDK and learn how to interact with PiecesOS through coding. In Part 2, we'll create a beautiful TUI using Textual.

What we'll build:

A chat interface with streaming responses
Chat management (create, view, delete)
Long-Term Memory (LTM) support
Real-time UI updates

Prerequisites:

Python 3.8+ (check with python --version)
PiecesOS installed and running (Download here)

Step 1: Setting Up Your Environment

Open or create a new folder for this project. You can name it whatever you’d like. Inside of the folder, follow the steps below:

Create a Virtual Environment

First, let's create an isolated Python environment for our project. Open up a command terminal, and enter the appropriate commands one by one below:


# Create a virtual environment
python -m venv venv

# Activate the virtual environment
## On macOS/Linux:
source venv/bin/activate

## On Windows:
venv\Scripts\activate

Install Dependencies

Still inside of your project folder, create a file called requirements.txt:

# PiecesOS Python SDK for interacting with PiecesOS
pieces-os-client>=3.0.0

# Textual TUI framework for building terminal user interfaces
textual[syntax]>=5.3.0

Inside of a command terminal, install the dependencies:

pip install -r requirements.txt

Step 2: Connecting to PiecesOS

Initialize the Pieces Client

The PiecesClient is your gateway to PiecesOS. Let's create a simple script to connect. Create a new file called test_connection.py:

# test_connection.py
from pieces_os_client.wrapper import PiecesClient

# Initialize the client
client = PiecesClient()

# Check if PiecesOS is running
if client.is_pieces_running():
    print("✅ Connected to PiecesOS!")
    print(f"Version: {client.version}")
else:
    print("❌ PiecesOS is not running. Please start it first.")

Go ahead and test it:

python test_connection.py

What's happening here?

PiecesClient() automatically discovers your PiecesOS instance port
is_pieces_running() checks if PiecesOS is accessible
The client handles port scanning and WebSocket connections

Step 3: Working with Chats

Now, let’s start working on creating and getting chats! First we’ll load all of your chats, then create a new chat, and then get that new chat:

List All Chats

# Add this section to the inside of 'if client.is_pieces_running()', as this all should only run if Pieces can connect.

# Get all chats
chats = client.copilot.chats()

print(f"Found {len(chats)} chats:")
for chat in chats:
    print(f"  - {chat.name}: {chat.summary}")

Create a New Chat

# Place this right below the code you just added above

# chats are created automatically when you ask a question
# without setting an active chat

# Clear current chat to create a new one when we call the stream_question method
client.copilot.chat = None

# You can also do this if you want to create one on the spot
# client.copilot.create_chat("My awesome chat")


# Ask a question - this will create a new chat
client.copilot.stream_question("What is Python?")

Load chat Messages

To make our new chat actually print, we have to print each raw_content that comes back from PiecesOS:

# Add this after 'client.copilot.stream_question("What is Python?")'

# Get all messages in the chat
messages = chats[0].messages()

for msg in messages:
    print(f"{msg.role}: {msg.raw_content}")

Step 4: Asking Questions with Streaming

One of the most powerful features is streaming responses. Instead of waiting for the entire response, you get chunks as they're generated, like you’d see in ChatGPT.

Basic Streaming Example

from pieces_os_client.wrapper import PiecesClient

client = PiecesClient()

def handle_stream(response):
    """Callback function for streaming responses."""
    status = response.status

    if status == "INITIALIZED":
        print("🤔 Thinking...")

    elif status == "IN-PROGRESS":
        # Get the text chunks
        if response.question and response.question.answers:
            for answer in response.question.answers.iterable:
                if answer.text:
                    print(answer.text, end='', flush=True)

    elif status == "COMPLETED":
        print("\n✅ Done!")

    elif status == "FAILED":
        print(f"\n❌ Error: {response.error_message}")

# Register the callback
if client.copilot.ask_stream_ws:
    client.copilot.ask_stream_ws.on_message_callback = handle_stream

# Ask a question
client.copilot.stream_question("Explain Python decorators")

⚠️ Error Handling Tip: In production, we will always handle WebSocket disconnections gracefully. The SDK will attempt to reconnect, but you should inform users about connection status.

Understanding the Streaming Flow

The streaming response goes through several states:

INITIALIZED: Copilot is preparing to respond
IN-PROGRESS: Streaming text chunks
COMPLETED: Response is complete
FAILED/STOPPED/CANCELED: Something went wrong

Step 5: Handling Streaming Properly

Let's create a more robust streaming handler:

# streaming_handler.py
from pieces_os_client.wrapper import PiecesClient
from typing import Callable, Optional

class StreamingHandler:
    """Handles streaming responses from Pieces Copilot."""
    def __init__(
        self,
        pieces_client: PiecesClient,
        on_thinking_started: Callable[[], None],
        on_text_chunk: Callable[[str], None],
        on_completed: Callable[[], None],
        on_error: Callable[[str], None],
    ):
        self.pieces_client = pieces_client
        self.on_thinking_started = on_thinking_started
        self.on_text_chunk = on_text_chunk
        self.on_completed = on_completed
        self.on_error = on_error

        self._current_response = ""

        # Register callback
        if self.pieces_client.copilot.ask_stream_ws:
            self.pieces_client.copilot.ask_stream_ws.on_message_callback = (
                self._handle_stream
            )

    def ask_question(self, query: str):
        """Ask a question and handle streaming."""
        self._current_response = ""
        self.on_thinking_started()
        self.pieces_client.copilot.stream_question(query)

    def _handle_stream(self, response):
        """Internal stream handler."""
        status = response.status

        if status == "IN-PROGRESS":
            if response.question and response.question.answers:
                for answer in response.question.answers.iterable:
                    if answer.text:
                        if not self._current_response:
                            # First chunk
                            self._current_response = answer.text
                        else:
                            # Subsequent chunks
                            self._current_response += answer.text

                        self.on_text_chunk(answer.text)

        elif status == "COMPLETED":
            self.on_completed()
            self._current_response = ""

        elif status in ["FAILED", "STOPPED", "CANCELED"]:
            error_msg = getattr(response, "error_message", "Unknown error")
                self.on_error(error_msg)
            self._current_response = ""

        except (AttributeError, ConnectionError, ValueError) as e:
            # Handle specific streaming errors
            self.on_error(str(e))
            self._current_response = ""

💡 Best Practice: Use specific exception types rather than broad except Exception handlers. This makes debugging easier and prevents masking unexpected errors.

Using the StreamingHandler

# Example usage
client = PiecesClient()

def on_thinking():
    print("🤔 Thinking...")

def on_chunk(text):
    print(f"{text}", end='', flush=True)

def on_done():
    print("\n✅ Done!")
    client.close()

def on_error(error):
    print(f"\n❌ Error: {error}")

handler = StreamingHandler(
    pieces_client=client,
    on_thinking_started=on_thinking,
    on_text_chunk=on_chunk,
    on_completed=on_done,
    on_error=on_error,
)

# Ask a question
handler.ask_question("What are Python generators?")

Step 6: Working with Long-Term Memory (LTM)

LTM allows Pieces to remember context across chats, making responses more personalized.

Check LTM Status

# Check if LTM system is running - place after ensure_initialization()
    if client.copilot.ltm.is_enabled():
        print("✅ LTM system is running")
    else:
        print("❌ LTM system is not available")
        # client.copilot.ltm.enable()

    # Check if current chat has LTM enabled - place after LTM system check
    if client.copilot.ltm.is_chat_ltm_enabled:
        print("✅ Chat LTM is enabled")
    else:
        print("❌ Chat LTM is disabled")

Toggle LTM for Chat

 # Enable LTM for current chat - place after LTM checks
 if client.copilot.ltm.is_enabled():
     client.copilot.ltm.enable()
     print("✅ Chat LTM enabled")
 else:
     print("❌ LTM system must be running first")

 # Disable LTM for current chat - place after enable LTM
    client.copilot.chat_disable_ltm()
    print("✅ Chat LTM disabled")

Step 7: Managing chats

Delete a chat

# Get a chat to delete - place after getting all chats
chat_to_delete = chats[0]

# Delete a chat - place after getting chat to delete
print(f"Deleting: {chat_to_delete.name}")
chat_to_delete.delete()

Rename a chat

# Get a chat to rename - place after getting all chats
chat = chats[0]

# Rename a chat - place after getting chat
chat.name = "My New Chat Name"
print(f"✅ Renamed to: {chat.name}")

Common Issues & Troubleshooting

### "Connection refused" Error

✅ Ensure PiecesOS is running
✅ Check if port 39300 is available

### "Module not found" Error

✅ Activate your virtual environment
✅ Reinstall dependencies: pip install -r requirements.txt
✅ Check Python version: python --version (needs 3.8+)

### Streaming Not Working

✅ Ensure callback is registered before stream_question()
✅ Check that PiecesOS is connected and responsive

Recap

In Part 1, we learned:

✅ Setting up a Python virtual environment
✅ Installing the PiecesOS SDK
✅ Connecting to PiecesOS
✅ Working with chats
✅ Handling streaming responses
✅ Managing Long-Term Memory
✅ Creating a robust streaming handler

Next Steps

In Part 2, we'll use everything we learned to build a beautiful Terminal User Interface (TUI) with:

Split-pane layout for chats and messages
Real-time streaming chat interface
Interactive widgets and keyboard shortcuts
Proper state management and UI updates

Useful Resources

Ready for Part 2? Let's build the TUI! 🚀

International Women’s Day: Spotlighting Our Women in Tech

Pieces 🌟 — Fri, 29 Mar 2024 17:32:04 +0000

The 8th of March was International Women’s Day, a day dedicated to celebrating and cherishing the hard work of women across the world. At Pieces, we hosted a roundtable discussion on Twitter space on March 21st where many of the women at our workplace shared their journey and experiences in the tech space.

There is a very good reason to celebrate women in tech; women are largely underrepresented in the technology field in general. According to this survey, women make up just 35% of employees in STEM in the US. These are shocking numbers, especially when it relates to receiving funds and promotions in the industry. Thanks to inclusive programs like Women In Tech (WIT), Women Who Code, Women in STEM, etc., more young girls and women have started embracing STEM as a career path.

We are grateful to the following women for sharing their experiences:

Leonie Bossemeyer, a Machine Learning Engineer, with an initial background in economics, is now pursuing her PhD in machine learning.
Laurin McNulty, Head of Design, is in her second year with Pieces, her first role out of college.
Erin Freeman, Growth Intern, graduating this May from Miami University in Communications and Entrepreneurship.
Rosie Levy, Chief Customer Officer, joined Pieces in December after working in software for 9 years in a variety of roles.
Anushka Gupta, Developer Advocate, is a computer science graduate who will be joining AWS soon as a programming manager.
Sophia Iroegbu, Developer Advocate, hosted this space, focusing on back-end development and technical writing.

Discussion Highlights

Overcoming Intimidation and Imposter Syndrome

Leonie, initially daunted by the expertise of her peers, reminds us that it's okay not to have all the answers at first. Sophia's transition from agriculture to tech highlights the diversity of backgrounds in the industry. Anushka's experience with coding highs and lows underscores the importance of resilience in the face of challenges, while Laurin, Erin, and Rosie share their battles with Imposter Syndrome, emphasizing the importance of continuous learning and building confidence.

Embracing Challenges and Seizing Opportunities

Rosie's journey from engineer to developer to product owner exemplifies the power of saying "yes" to new experiences, even when they seem daunting. Leonie's thinking outside of the box approach, such as her discovery of an older, simpler, yet effective algorithm to solve a problem, showcases the value of humility and perseverance in tech. Additionally, the projects undertaken by Laurin and Erin, from project management to growing developer communities, demonstrate the growth that comes from stepping out of one's comfort zone and embracing new responsibilities. It’s okay to be clueless when you are just getting started.

Balancing Work and Life

Beyond the code, these women emphasize the importance of maintaining a healthy work-life balance. From Laurin's dedication to a hobby like painting to Erin's strategic scheduling and self-care practices, each woman emphasizes the need to prioritize personal well-being alongside professional growth. On the other side, Leonie expresses that sometimes work can be so compelling and exciting that it can be both your work and your hobby, as long as you are achieving what you want to be achieving and doing work that makes you happy.

Paving the Way for Future Generations

In their commitment to diversity and inclusion, these women speak on the importance of making strides in their own careers but also actively working to create opportunities for others. Anushka's advocacy for open-source programs and Rosie's mentorship of high school interns highlight the importance of nurturing talent from a young age. Similarly, Laurin, Erin, and Leonie stress the significance of representation and allyship in fostering an inclusive tech community. All of the women of Pieces agree that diversity begins with them, in hiring, in advocating for voices that aren’t being heard in the conference room, and championing each other every single day.

Words of Wisdom and Encouragement

As the discussion draws to a close, each woman offers their own advice to those navigating their own tech journeys:

Laurin: Embrace change, have confidence in yourself, and never stop learning.
Anuskha: It's okay not to know everything; take your time to learn and grow.
Leonie: Dive into projects that interest you; they provide the perfect opportunity for learning.
Rosie: Struggling is part of the journey; remember that others face similar challenges, so keep pushing forward.
Erin: Step out of your comfort zone, build new skills, and try things that scare you.
Sophia: Start small, tackle challenges head-on, and remember it's okay to take breaks when needed.

Moving Forward with Confidence

As we reflect on the insights shared by these trailblazing women, one thing becomes clear: the tech industry is richer and more vibrant when diverse voices are heard and celebrated. With their resilience, passion, and unwavering dedication, they inspire us all to embrace challenges, uplift one another, and forge ahead with confidence on our own paths to success.

Here are some communities you can join to network with other women across the world:

Conclusion

As we drew closer to the end of the session, we discussed a bit more on time management, avoiding regrets, and being happy with who you are and where you are. Our heartfelt wish is that these roundtable discussions inspire you to keep going, keep building, keep growing, keep learning, and keep connecting and uplifting the women you connect with.

You can listen to the full recorded conversation here.

AI Coding: The Ultimate Guide to Enhancing Your Development Workflow

Pieces 🌟 — Wed, 27 Mar 2024 16:07:27 +0000

As developers, the love of the craft can get away from us when we have to spend time on mundane tasks — repeating code, searching for bugs, and reading boring documentation. With AI coding tools, it is starting to look like a light at the end of the tunnel. Can we get back to the fun times of using our imagination and letting our creative juices flow to solve some abstract problem? The answer is yes.

A recent report highlights the staggering efficiency gains and cost reductions companies are experiencing by integrating AI into their development workflows. According to this study, projects that utilize AI coding tools see a reduction in development time by up to 50%, along with a significant decrease in bugs and errors at the initial stages.

Developers can now focus on creative problem-solving and strategic planning, leaving the repetitive and time-consuming coding tasks to their AI counterparts. Let’s take a close look at how you can make the most of these AI tools for coding and stay ready for what lies ahead.

Understanding AI Coding

To put it simply, AI coding includes the application of machine learning models to understand, generate, and optimize code. This field is massive, ranging from simple code suggestions to complex algorithms that can write and refactor entire segments of code autonomously.

The types of AI coding tools vary significantly too, each serving distinct purposes. For instance, code completers like Intellisense or GitHub Copilot help developers by suggesting the next line of code based on context. The result is a significant speed boost in the overall coding process.

Bug detectors are invaluable in identifying potential errors before they become a problem, saving time in the debugging phase. AI code reviewers go a step further by not only spotting errors but also providing suggestions for code quality improvements, ensuring adherence to best practices.

Question/answering tools are designed to assist developers in finding quick solutions to coding queries, while AI coding assistants and code generation tools, like Pieces for Developers, offer the ability to generate code snippets from natural language descriptions, thus streamlining the development workflow significantly.

Machine learning and AI are integral to coding because they can analyze vast amounts of data quickly and learn from it. In coding, these models are trained on large datasets of code to understand syntax, semantics, and even code structure, which enables them to predict and generate code accordingly. Safe to say, this comes with some sweet benefits.

Benefits of AI in the Software Development Industry

The benefits of using AI for coding tasks are numerous. We already mentioned how it increases productivity by automating repetitive tasks, improves code quality through consistent application of best practices, and can significantly reduce the time spent on debugging. But how can we put this into numbers?

Another recent article outlines the potential for generative AI coding tools to boost global GDP by over $1.5 trillion, attributing this to a 30% productivity enhancement. These tools could add the equivalent of 15 million "effective developers" to the global workforce by 2030.

But it isn’t just big companies seeing the benefits of AI in coding. Less experienced developers benefit more from tools like Pieces and GitHub Copilot, which help them upskill and become more fluent in their programming languages of choice.

Developer burnout and context-switching are no fun. Constantly having to move from one task to another without letting your brain catch up can make it so you don’t even want to get out of bed in the morning and sign into that daily standup meeting. Knowing that you can offload the grunt work to AI-assisted coding tools makes it a little easier to go to work every day and keep on coding.

Key Technologies Behind AI Coding

The primary engines behind coding with AI are Large Language Models (LLMs), neural networks, and various machine learning algorithms. LLMs, like GPT and Gemini, have revolutionized the way we think about human-computer interaction by processing and generating human-like text.

Neural networks, particularly deep learning models, mimic the human brain's interconnected neuron structure to parse data and learn from it, making them ideal for pattern recognition and predictive analytics essential in coding tasks.

How are These Technologies Applied in Coding?

These technologies come into play in AI-based coding by automating repetitive tasks, suggesting code completion, finding and fixing bugs, or even generating code snippets based on natural language descriptions. The problem, however, often lies in the context. Traditional models could churn out code, but understanding the broader context of that code within a project or a developer's unique coding style was beyond their reach.

This is where Retrieval-Augmented Generation (RAG) steps in, making a significant impact on AI and coding. RAG enhances the capabilities of LLMs by combining them with an extensive database, such as codebases or internal wikis, which the model can draw upon to provide context-specific information.

This means that when you use a tool like Pieces, it's not just suggesting code — it's suggesting code that aligns with the context of your entire workflow. It understands the nuances of your project and adapts to the specific environment you're working in, be it an app, complex software, or a web development project.

AI Coding Tools and Platforms

Let’s take a closer look at Pieces and a few other popular AI coding tools.

Pieces for Developers - Revolutionizing AI Coding

Pieces for Developers is an AI productivity tool that's gaining attention for its unique approach to enhancing developer workflows. There are three key components that make Pieces a particularly special AI tool for coding to keep on your radar:

Retrieval Augmented Generation
Cross-platform LLM utilization
On-device processing

At its core, the application functions as a copilot, persisting across the various stages of software development, from coding to collaboration. This persistence is powered by the previously mentioned RAG technique that ups the performance of generative AI models by incorporating external data sources to provide more accurate and contextually relevant responses.

What separates this technique from others is that it addresses the issue of "hallucinations" in AI responses by blending code generation with information retrieval. It enhances the accuracy and relevance of AI-generated content, and as a result, is more reliable for enterprise applications where factual accuracy is crucial.

Cross-platform LLM utilization is one of the key differences between Pieces and other AI-powered coding tools. In practice, this means whether a developer is working in Visual Studio Code, JupyterLab, Chrome, or any other tool, they can expect a consistent level of support from Pieces. LLMs can be leveraged to understand and generate code across a variety of programming languages and frameworks, making the tool versatile and adaptable to different development environments.

On-device AI processing means that the AI's computations are done locally on the developer's machine, rather than on remote servers. This approach is crucial for handling sensitive code because it mitigates the risk of exposing intellectual property or confidential information to external entities. Pieces takes advantage of this to ensure that developers' code remains private and secure while still benefiting from advanced AI-powered coding capabilities.

Pieces isn't just a single tool — it's meant to be a suite of tools that assist at various stages of software development. We’re talking everything from real-time code completion, bug detection, and automated refactoring suggestions while coding. There is also the integration with version control systems to help manage changes or predict the impact of code modifications.

Plus, Pieces doesn't just provide raw code snippets but enhances them with additional context or documentation. For instance, when a developer finds a snippet of code, Pieces can automatically annotate it with comments, link to the relevant function's documentation, or even provide visual aids that explain what the code does.

GitHub Copilot

Released by GitHub in partnership with OpenAI, GitHub Copilot is an AI-powered code completion tool that provides suggestions for whole lines or blocks of code. It's designed to be a sort of pair programmer, and help developers code faster and learn new APIs and languages along the way.

Similar to Pieces, instead of typing out boring boilerplate, you can just select it from a list of suggestions while you’re coding in your IDE. It’s great at what it does, and even though it charges $10 per month, many devs swear by it.

GitHub Copilot isn’t the only AI used for coding in town though, and we’ve discussed a few alternatives to GitHub Copilot in a previous article. A few of the standout competitors are from other tech giants that you’ve probably heard of — namely Microsoft and Amazon.

Microsoft Copilot

Microsoft Copilot may be newer than GitHub Copilot, but it has been a long time in the making. If you’ve been using VS Code for a few years, you might remember the built-in code completion, IntelliSense. You can think of it as a form of AI, but it is more basic than that.

IntelliSense first made its appearance in a mainstream product with the release of Visual Basic 5.0 Control Creation Edition in 1996. By Visual Studio 2005, IntelliSense became more context-aware and proactive, activating by default as the user begins to type.

Fast forward to 2023, and Microsoft Copilot represents a newer generation of AI integration, leveraging large language models to assist in a broader range of tasks beyond coding, including writing, creating, and summarizing content across Microsoft's suite of products.

Amazon CodeGuru

CodeGuru is a machine learning service by Amazon Web Services that provides automated code reviews and performance recommendations. Amazon CodeGuru leverages machine learning to enhance code quality by providing automated code reviews and performance recommendations.

It identifies your inefficient and problematic code segments and suggests improvements to both the performance and cost-efficiency of applications. CodeGuru is split into two main components: CodeGuru Reviewer, which conducts automated code reviews for potential issues, and CodeGuru Profiler, which identifies application performance bottlenecks.

Cloud-based or Local AI?

All these AI assisted coding tools can make your head spin, but you shouldn’t jump into any particular one without figuring out how it will work within your environment, especially if you’re aiming to become an AI-powered enterprise. The biggest question you should ask yourself first is whether it is cloud-based or local?

Choosing the best LLM between cloud-based or local LLMs for coding hinges on balancing specific requirements and constraints. Cloud LLMs offer the advantages of scalability, ease of use, and reduced need for upfront hardware investment, making them a compelling choice for those needing rapid deployment and flexibility.

On the flip side, local LLMs provide greater control over data and processing, enhanced privacy, and the potential for customized optimizations, catering to those prioritizing data security and specific performance needs. The decision ultimately rests on aligning the LLMs capabilities with your specific performance expectations, hardware availability, and privacy concerns.

Don’t Forget About Integrations

Integrating AI coding tools with IDEs, browsers, and collaboration platforms is essential for modern software development. Such integration streamlines the workflow, allowing developers to remain within their coding environment while accessing a wealth of information and functionalities.

For instance, the top AI tools for coding are integrated with IDEs to provide real-time, context-aware coding assistance, which can drastically improve productivity and reduce errors. When these tools are synced with web browsers, they simplify research and problem-solving by bringing intelligent assistance into the research phase, ensuring that insights and code snippets are easily accessible and relevant.

You need a transition between solitary code writing and team-based activities, such as code reviews or collaborative problem-solving. An AI coding tool that unifies these aspects within the workflow doesn't just save time but also preserves the mental flow of developers, reducing the cognitive load and context switching that often lead to inefficiencies.

Best Practices in AI Coding

Effectively integrating AI into your workflow isn’t difficult. But you should keep some AI coding basics and best practices in mind to make the most of it. Here are a few ideas to keep you on your toes:

Understand the capabilities and limitations. Before integrating the best AI tool for coding, think about what it can and cannot do. AI can offer suggestions, generate code, and automate repetitive tasks, but it may not always grasp the nuanced requirements of a project. Knowing this helps set realistic expectations. At least in the beginning, stick to using it for boilerplate code generation, bug fixes, or help with understanding documentation.

Maintain code quality standards. AI-generated code should keep to the same quality standards as manually written code (or better). This means you’ll still have to conduct the same old code reviews, maintain proper documentation, and run tests at each stage to ensure the generated code meets your project's standards. Yeah, this might be the boring stuff — but the best AI for coding should take most of the drudgery out of it.

Prioritize security. When experimenting with coding and AI, make sure that the code generated does not introduce any security vulnerabilities. If you’re relying on cloud-based systems, try and move away from them. Remember how we said Pieces can use offline AI to run locally on your machine? This is one of the best ways to ensure security.

Incorporate human oversight. AI should augment, not replace, human developers. Always have experienced developers oversee the AI's output and keep the necessary checks and balances to catch errors the AI might miss.

Train the AI with your codebase. If your AI tool supports it, train the model with your codebase to improve its context-awareness. The more the AI understands your specific environment (as opposed to just general knowledge), the better its suggestions and code contributions will be.

The Future of AI Coding

The impact of AI on the future of software engineering is profound, to say the least. We’re only a year or two into the current AI upswing — a couple years ago, all of these capabilities and AIs for coding help were unheard of.

Researchers at MIT are saying that as AI coding tools continue to evolve, they are expected to handle more complex aspects of software development, beyond simple code generation. This could include managing large codebases, identifying and fixing bugs autonomously, and optimizing software for performance and security. The promise of AI in software development lies not just in augmenting human capabilities but in fundamentally transforming the coding process.

Additionally, the best AI coding assistants not only alleviate the tedium of certain coding tasks but also enhance developers' creativity and empower them to tackle more complex problems. The folks over at GitHub are saying AI is completely changing the way developers work, claiming these advancements have led to increased productivity, with developers reporting faster coding times and a reduced sense of frustration during the coding process.

But even with all of the promising news, there is a gray cloud hovering on the horizon. For example, the use of GitHub Copilot and AI tools like ChatGPT for coding have raised concerns regarding intellectual property and data privacy, leading some companies to restrict their use. Additionally, there are ongoing legal debates around the training of AI models with code that may have been used without explicit consent from the original authors.

Besides the potential legal issues, there is also the question of the intelligent developer going extinct. That might sound a little dramatic, but let’s not forget that the CEO of Nvidia recently said that programming is a dying profession, soon to be replaced by AI that solves coding problems.

And the question remains: if AI does all the work, does the developer learn anything? Do they maintain their skills? For new devs coming into the field, do they need to learn anything at all?

We like to think on the bright side. As of right now at least, you can’t ask for AI to create a full-stack app from scratch and handle all of the nuanced user stories, requirements, and issues with deployment and scaling. We need developers, and despite a potential shortage of them due to AI, we can still leverage the best AI to learn coding to create more efficient and intelligent software engineers. We actually think there’s a lack of software developers due to AI.

Conclusion

From dramatically reducing development times and enhancing code quality to bringing about a more satisfying development experience, AI coding tools are reshaping the industry's future. Adopting AI coding tools is increasingly essential for developers aiming to stay ahead. One such AI that can help with coding is Pieces for Developers.

Check out Pieces for yourself and join a helpful community of developers who are shaping coding's future with AI. Boost your productivity, improve your code quality, or just enjoy coding more — Pieces is your go-to.

AWS CodeWhisperer vs Copilot: Features and Issues

Pieces 🌟 — Wed, 27 Mar 2024 16:00:24 +0000

Given the existence of “the first AI software engineer,” it is increasingly important that developers use an AI assistant to be more productive. The increase in productivity can come from (1) cleaner, more maintainable code with fewer errors, (2) automating repetitive tasks such as writing boilerplate and code completion, (3) offering suggestions and variations of existing code, (4) retrieving desired information from your previous workflow, and other types of intelligent assistance.

However, AI output needs to be checked for accuracy and not trusted unless reviewed by a human. For example, various AI systems have invented variables that do not exist in reality, explained hallucinated policies to customers, and opened code to security vulnerabilities. In the legal system, an AI has supported false facts with imaginary sources.

Consequently, it is crucial to consider carefully when choosing your AI assistant. This post discusses the three best choices for a developer’s AI copilot, and compares their features and issues. The copilots are GitHub Copilot vs Amazon CodeWhisperer, and those are compared with a third alternative, Pieces for Developers.

GitHub Copilot Features and Issues

After a year of technical preview, GitHub Copilot was released for individual developers on a monthly subscription basis in June 2022. It uses Open AI’s Codex LLM, which was derived from GPT-3. Codex is specialized to translate natural language into code.

Microsoft bought GitHub for $7.5 billion in stock in June 2018, and Microsoft collaborated with OpenAI to create GitHub Copilot before the Codex LLM was publicly released. GitHub provided an immense code database for training Copilot’s AI model, and Azure is an immensely scalable cloud environment that supports Copilot.

In March of last year (2023), GitHub Copilot evolved to GitHub Copilot X as a “readily accessible AI assistant throughout the entire development lifecycle.” This was achieved by integrating it into Visual Studio and VS Code. It also supports Vim, Neovim, the JetBrains suite of IDEs, and Azure Data Studio. Some of the GitHub Copilots experimental features ended December 15, 2023, and others, such as Workspaces, are ongoing.

The intent of Workspaces is to guide a developer from initial idea to production and beyond. It combines GPT-4 with the available relevant codebase to provide better information during the entire development lifecycle process.

Earlier this year (February 27, 2024), GitHub Enterprise was introduced to developers as “a copilot that is customized to their own organization’s code and processes.” The GitHub Blog describes the “three core features” of the GitHub Copilot Enterprise release.

The first core feature is the set of standard copilot features. It generates summaries of code and makes real-time suggestions to explain and improve code. At this time, there is an unanswered question about the context used by the Copilot. When a developer had two projects open in JetBrains Webstorm, it used both projects as a basis for its suggestions.
The second core feature is the direct integration of chat into GitHub.com. This allows developers to query their organization’s codebase in natural language and to be guided to relevant code or documentation that might answer a question.
The third core feature is faster review and integration of pull request results into code. The Copilot summarizes pull requests and analyzes pull request diffs, which is useful to developers who review pull requests.

The GitHub Blog explicitly states the vision for evolving GitHub Copilot is focused on AI integration for GitHub. I noticed that GitHub Copilot Enterprise has the integration of Microsoft’s Bing search into chat in beta. It does not mention using a code snippet as an example to find similar snippets, which is a search that can be done in Pieces.

The Copilot’s AI model is not trained on any of an organization’s information unless it is introduced by organizational request. For example, GitHub Copilot can use a custom AI model and it can be fine-tuned for esoteric languages, such as Verilog for hardware design.

A study of the simpler GitHub Copilot provides strong evidence for the benefits of using it. A major enterprise surveyed 450 of its Copilot users for their Activity, Productivity, Efficiency, and Satisfaction in using it. All eight data values in the results were highly positive. Five were in the range of 90%-96%. Developers retained 88% of the suggested code, there was an 84% increase in successful builds, and 50% did more builds.

Thus, it is very clear that developers’ use of even the simplest auto-completion copilot is highly beneficial. The benefits increase with more intelligent copilots, especially when the copilots are designed with the developers’ specific use cases in mind. More advanced copilots understand and make suggestions relevant to regulations, policies, standard practices, and personal preferences.

For security, data is encrypted. However, it is accessible to Microsoft and GitHub personnel, especially the data belonging to individuals. Individuals can turn off retention of prompts and suggestions, and they are not saved when on a business plan.

There is a lot of community support at various levels of expertise. This can be especially useful for students and developers new to coding in a language, who have questions that go beyond interactions with the AI itself.

The AWS Copilot Competitor

Amazon launched the AWS CodeWhisperer into technical preview in June 2022, within hours after GitHub Copilot was publicly launched. Now, the two frequently compared copilots are Amazon CodeWhisperer vs GitHub Copilot.

CodeWhisperer is a direct challenge to Microsoft's GitHub Copilot, especially for developers whose work involves the AWS environment. It was trained on billions of lines of code and, according to Amazon, it continues to train on “open source repositories, internal Amazon repositories, API documentation, and forums.”

CodeWhisperer uses the developer’s current context to make suggestions, including four primary sources: (1) the current location of the cursor in a body of code, (2) the code that comes before the cursor, (3) any available comments, and (4) the code it finds in other files in the same project.

Like Microsoft focuses GitHub Copilot on GitHub, Amazon focuses CodeWhisperer on AWS. It writes code for accessing AWS’s services that conforms to the AWS best practices. For example, it offers suggestions for APIs such as Amazon EC2, AWS Lambda, and Amazon S3.

There is also a reference tracker that flags code that may have plagiarism issues with open-source code. There is a filter that can be turned on to keep this code out of the code suggested by the AI.

Like GitHub Copilot, business data is not stored or used by Amazon, but individuals have to opt out of their data being stored.

The biggest general differentiator in AWS CodeWhisperer vs GitHub Copilot is the support for the AWS environment. This is a tremendous help, especially if you need to access AWS services but not often enough to have the code memorized.

Pieces for Developers

The team that created Pieces for Developers has and will continue to have a very different focus than Amazon and Microsoft. The company’s sole focus is identifying and satisfying the needs of developers. It is backed by some of the world’s best investors, and it is secure and continuing to grow.

In 2022, the Pieces team set out to build the most advanced code snippet management and workflow context platform. It would use AI to augment and streamline a developer’s workflow and have an on-device personal mini-repository that stores the materials written and used by a developer. The goal was (and still is) to save the developer’s time while decreasing stress and helping the developer be more productive.

The Pieces Suite, which is free to individuals, became a “tool-between-tools” that integrates three major workflow processes: (1) researching and problem-solving in the browser; (2) writing, reviewing, referencing, and reusing code in the IDE; and (3) working with colleagues in collaborative environments such as Microsoft Teams.

Pieces saves reusable and valuable code from the browser, the IDE, and directly from teammates when shared in Teams. These pieces of code are stored with intelligently enriched titles, explanations, tags, user annotations, and 15+ other enrichments. A developer saves countless hours because it is easy to find the right snippet, understand the appropriate context, and then plug it into the code.

In summary, Pieces for Developers brings your tools to one place with all necessary capabilities like saving code, searching for it when it matters, reusing it seamlessly, and sharing it with one click! See how Pieces compares as a GitHub Copilot alternative.

GitHub Copilot vs AWS CodeWhisperer vs Pieces

When comparing GitHub Copilot vs CodeWhisperer, both AI code generation tools are excellent. However, their code-snippet capabilities are much less than those already provided by Pieces’ fundamental focus on workflow.

Pieces for Developers includes the desktop mini-repository with any, some, or all of Pieces integrations for browsers (Chrome, Edge, Firefox), IDEs (VS Code, JetBrains IDEs, JupyterLab, Azure Data Studio, Obsidian), and collaborative environments (Microsoft Teams). Others are in process and will be released soon.

Compare the following list of ten feature categories with the features of any copilot you are considering. Then, If you are an individual developer, remind yourself that all the features included in all of Pieces are free.

Manage Your Resources. Keep track of snippets, screenshots, and workflow context in an on-device AI hub for developer materials.
Instantly Enriched. Benefit from AI-powered enrichment providing titles, descriptions, tags, documentation links, relevant collaborators, and so much more.
Your Personal Google (Offline & Online). Find the materials you need with a lightning-fast search experience that lets you query by natural language, code, tags, and other semantics, depending on your preference.
Your Personal Copilot. Ask the Pieces Copilot to generate code, connect you with teammates, or summarize what you worked on yesterday. It can run entirely offline and on-device, and it understands text, images, videos, and even entire local directories. It also can access the repository for anything you saved to Pieces while in a browser, IDE, or collaborative environment like Teams.
Easier to Share. Maintain invaluable context (such as people’s names) for your shared resources when collaborating with teammates, writing technical documentation, or publishing tutorial videos with custom shareable links.
Smart Transforms. Transform your snippets in a single click to improve readability, formatting, or runtime performance. You can even translate a snippet to your preferred programming language or convert it to boilerplate.
Workflow Backtracking. Easily pick up where you left off by revisiting what you searched, copied, saved, shared, referenced, and more because you have a chronological compass capturing the "when" and "where" of your workflow.
Code from Screenshots. Pieces upgrades screenshots with OCR and its AI extracts code and repairs invalid characters, which results in extremely accurate code extraction and deep metadata enrichment.
Persistent Conversations. Move seamlessly from browser to IDE to Teams in any sequence without breaking your connection to your AI assistant.
Support and Updates. Check what support is offered through what channels and how quickly issues are resolved and updates are released.

Conclusion: CodeWhisperer vs Copilot

Other copilots are sometimes included in comparisons, such as GitHub Copilot vs ChatGPT vs Tabnine. I did include Tabnine in a previous low-level comparison of copilot features, but it was too limited to include in this post. One limitation is that it is not integrated into any browsers, but GitHub Copilot vs AWS CodeWhisperer also have that limitation.

When choosing an AI coding assistant, the primary considerations are development environment, development/coding style, preferred language(s), budget, and, if any, your specific needs. If you need a copilot that is tied to the Azure or AWS environment, then your optimal choice will be the copilot designed for that environment.

When not bound to an environment, Pieces would probably be your optimal choice. With its advanced features and focus on the overall workflow, it would probably give you the greatest increase in productivity and it is free (to individuals). If doubting which to choose, I suggest using the list of feature categories in the previous section as the checklist for comparisons.

Get started with Pieces for free today!

Top 10 Kotlin Code Snippets to Keep Handy

Pieces 🌟 — Tue, 19 Mar 2024 16:00:53 +0000

Kotlin is the cross-platform, general-purpose, open-source programming language developed by JetBrains. It is fully interoperable with Java. According to Stack Overflow, Kotlin is the 4th most loved language among the developer’s community, and it is the preferred language for Android development.

Google announced first-class support for Kotlin on Android in addition to the existing languages – Java and C++ – at Google I/O in 2017. Google also announced Kotlin as its preferred language for Android development on May 7, 2019.

Rather than searching through your notes, codebase, and search history endlessly, you can use Pieces for Developers to organize useful code snippets along with useful links, tags, descriptions, anchors, and titles for each snippet, making it a lightning fast task to retrieve one whenever you need it.

In this article we will look at a curated list of the best Kotlin code snippets for beginners and advanced developers who want to enhance their productivity & skills with this powerful language.

Let’s get started!

1. Delegated Properties

Delegation is defined as granting authority or power to the person to carry out different tasks. Similarly, Kotlin provides the language support for delegation using Delegation properties.

This feature allows you to create and implement properties only once and then use them continuously to delegate other code work in the application.

Delegation is the design pattern where an object or property delegates the task to the other helper object instead of performing the task itself.

In the code below, a property name in our Demo class delegates the logic for getter and setter to DelegateHelperClass(), so anything after that keyword satisfies the conversion for the property delegates to act as a Delegate.

Let's dive into how delegated properties work with a code example:

class Demo {var name: String by DelegateHelperClass()}

Save this code

2. Smart casts

Other programming languages, including Java, require explicit type casting on variables before accessing their properties. However, there is a feature in Kotlin called smart casting that tracks conditions within the if expression.

If the Kotlin compiler discovers a variable that is not null and has a type equal to nullable, only then the compiler will allow access to that variable. The is or !is operator can be used to check the type of a variable, and the compiler will automatically cast the variable to the target type as shown in the code.

fun main(args: Array< String >) 
{val str1: String? = “Hello World”var str2: String? = null 
// prints String is nullif(str1 is String) 
          {// No Explicit type Casting needed.println(“length of String ${str1.length}”)}
else 
          {println(“String is null”)}}

Save this code

3. Elvis Operator (?:)

The Elvis operator in Kotlin, represented as ?:, offers a concise way to handle nullability. It returns the expression on the left if it's not null, otherwise, it evaluates and returns the expression on the right. This snippet is handy when dealing with nullable types, preventing null pointer exceptions.

val result = nullableValue ?: defaultValue

Save this code

Use Case: Use the Elvis operator to provide a default value when dealing with nullable variables, simplifying null checks.

4. Safe Call Operator (?.)

The safe call operator, denoted by ?. in this Kotlin code snippet, allows accessing properties or invoking methods on nullable objects safely. It returns null if the object is null, preventing NullPointerExceptions.

val length = nullableString?.length

Save this code

Use Case: Employ the safe call operator Kotlin snippet when working with nullable objects to access their properties or methods without risking null pointer exceptions.

5. String Interpolation

Kotlin supports string interpolation, enabling the embedding of expressions directly into strings. Enclose the expression in curly braces preceded by a dollar sign (${expression}).

val name = "John"
val greeting = "Hello, $name!"

Save this code

Use Case: Utilize string interpolation for dynamic string construction, enhancing code readability and maintainability.

6. Extension Functions

Extension functions allow adding new functionalities to existing classes without modifying their source code. They enhance code reusability and facilitate a more fluent API design.

fun String.addExclamation(): String {
                             return "$this!"
                             }

Save this code

Use Case: Employ extension functions to extend the functionality of existing classes, promoting code organization and maintainability.

7. Data Classes

In Kotlin, data classes are a special type of class that is primarily used to hold data. They are designed to reduce boilerplate code by automatically generating several standard methods such as equals(), hashCode(), toString(), and copy().

In this Kotlin code snippet below, we define a data class named User with two properties: name of type String and age of type Int. By simply declaring the class with the data modifier, Kotlin automatically generates the equals(), hashCode(), toString(), and copy() methods for us.

Using data classes simplifies working with immutable data. In the example, we create a User object named user with the name "Alice" and age 30. Since User is a data class, we can easily access its properties, compare objects for equality, generate hash codes, and create copies without writing additional boilerplate code.

data class User(val name: String, val age: Int)
val user = User("Alice", 30)

Save this code

Use Case: Use data classes to represent immutable data, reducing boilerplate code and enhancing readability.

8. Higher-Order Functions

Higher-order functions accept other functions as parameters or return them. They enable concise and expressive code, promoting functional programming paradigms. They can take other functions as parameters or return functions as results. In Kotlin, functions are first-class citizens, meaning they can be treated like any other value, such as integers or strings. This allows for the creation of higher-order functions, which enable more concise and flexible code.

fun operateOnNumber(number: Int, operation: (Int) -> Int): Int
{
 return operation(number)
}

val squared = operateOnNumber(5) { it * it }

Save this code

Use Case: Leverage higher-order functions to encapsulate common behaviors and promote code reuse.

9. Null Safety with !! Operator

Although not recommended, the double exclamation mark (!!) operator can be used to assert that an expression is not null. It throws a NullPointerException if the expression evaluates to null.

val length = nullableString!!.length

Save this code

Use Case: Exercise caution when using the !! operator, as it bypasses null safety checks and can lead to runtime exceptions.

10. Default Arguments

Default arguments in Kotlin allow you to specify default values for function parameters. This means that when you call a function without providing values for certain parameters, those parameters will be initialized with their default values.

Default arguments, like this Kotlin snippet, provide a convenient way to define functions with a varying number of parameters while allowing callers to omit some of them if they're not necessary. Kotlin supports default arguments in function parameters, allowing the omission of arguments when calling functions.

fun greet(name: String = "World") {
 println("Hello, $name!")
}
greet() // Output: Hello, World!

Save this code

Use Case: Utilize default arguments to define flexible function interfaces and simplify function calls.

Bonus Snippet: Inline Functions

Inline functions in Kotlin are marked with the inline keyword and are expanded at the call site, reducing the overhead of function calls.

inline fun performOperation(value: Int, operation: (Int) -> Int): Int { return operation(value) }

val result = performOperation(5) { it * it }

Save this code snippet

Use Case: Use inline functions to improve performance by eliminating the overhead of function calls for small functions or lambdas.

Conclusion

Kotlin's powerful features empower developers to write concise, expressive, and safe code. By leveraging Kotlin snippets like the Elvis operator, extension functions, and higher-order functions, developers can enhance productivity and maintainability.

Understanding and mastering these features is key to unlocking the full potential of Kotlin and building robust applications efficiently. Experiment with these Kotlin code snippets in your projects, and witness firsthand the elegance and efficiency of Kotlin programming.

With this we conclude our curated selection of top-notch Kotlin boilerplate snippets — a valuable resource for both experienced Kotlin developers and beginners alike.

To streamline your coding journey and enhance your learning curve, the Pieces Web Extension offers a convenient feature. With just a few clicks, you can effortlessly copy and save any of these Kotlin boilerplate code snippets from our list, ensuring quick access whenever you require them.

What's even more intriguing is that by saving a snippet in Pieces, you'll gain deeper insights into these boilerplate Kotlin snippets, including tags, context, and relevant links. Why not give it a try? Simply click one of the links above to save the code snippets, enriched with tags and all the context you need, saved into a personal, on-device repository. First you need to install the Pieces Desktop App.

We trust that this article has provided you with a solid understanding of useful Kotlin boilerplate snippets and when to apply them in your projects. You can find more useful snippets for other languages with our snippet collections.

How to Run an LLM Locally with Pieces

Pieces 🌟 — Mon, 18 Mar 2024 20:31:49 +0000

The demand for local, secure, and efficient machine learning solutions is more prominent than ever, especially for software developers working with sensitive code. At Pieces for Developers, we understand the importance of leveraging Local Large Language Models (LLLMs) not just for the enhanced privacy and security they offer, but also for their offline AI capabilities. Our commitment to a local-first philosophy has led us to support CPU and GPU versions of popular LLMs like Mistral, Phi-2, and Llama 2, with more on the way.

Our focus on privacy and security goes beyond the ability to leverage LLLMs within Pieces Copilot. In order to ensure all of your data remains on your local machine rather than transmitting it over the internet, we’ve meticulously fine-tuned several small language models so that anytime you store code snippets in Pieces, your code can be automatically enriched with titles, descriptions, tags, related links, and other useful context and metadata, without needing to connect to the cloud.

While small language models can be supported on almost any machine, running LLMs locally that have 7 billion parameters or more can bring challenges, especially considering the hardware requirements. We still consider our on-device AI as “experimental”, as this implementation and the availability of these models is so new, and we can’t always guarantee success for our users. This guide aims to demystify how to run an LLM locally within Pieces, outlining the minimum and recommended machine specs, the best GPUs for LLMs locally, and how to troubleshoot common issues when using Pieces Copilot in your development workflow.

Understanding Local LLM Hardware Requirements

Navigating the hardware requirements to run an LLM locally is crucial for developers seeking privacy, security, and the convenience of offline access. This section discusses the essential hardware components and configurations needed for efficiently running large language models locally, and how to check your machine’s specs to determine what it can handle.

Minimum and Recommended Specifications

Local LLMs, while offering unparalleled privacy and offline access, require significant machine resources. For an optimal experience, we recommend using machines from 2021 or newer with a dedicated GPU boasting more than 6/7GB of available GPU-RAM (VRAM). Older machines or those without a dedicated GPU may need to opt for CPU versions, which, while efficient, may not offer the same performance level.

As a user, if you are receiving the error message “I’m sorry, something went wrong with processing…” or the Pieces application crashes when you are using a local model, you may be trying to run a local model that requires more resources than your machine has available, or you’ve selected a GPU model when you don’t have a dedicated GPU, and you will need to change it. Unfortunately, if you have an older machine or one with very low resources, you may have to use a cloud model in order to use the copilot.

GPU vs CPU

Central Processing Units (CPUs) and Graphics Processing Units (GPUs) serve distinct functions within computing systems, often collaborating for optimal performance. CPUs, the general-purpose processors, are key for executing a broad range of tasks, excelling in sequential processing with their limited number of cores. They're crucial for running operating systems, applications, and managing system-level tasks.

Conversely, GPUs specialize in accelerating graphics and data-heavy tasks. Originating in video game graphics, GPUs now handle tasks requiring parallel processing like video editing, scientific simulations, and machine learning, thanks to their thousands of cores. While most computers have both CPUs for general tasks and GPUs for graphics-intensive work, some may only include integrated graphics within the CPU for basic tasks, opting for compact designs over dedicated GPUs.

The Best GPUs for Local LLMs

When it comes to running local LLMs, the GPU plays a pivotal role. Dedicated GPUs with high VRAM are preferable, as they can significantly speed up computations required by these models. NVIDIA's GeForce RTX series and AMD's Radeon RX series are excellent choices, offering a balance between performance and power efficiency.

When it comes to Apple products, the new M-series machines do not use dedicated GPUs, but the integrated GPUs they have are more than sufficient to run local LLMs.

Checking Your Machine Specs

In order to select the best on-device LLM for you, you should first check your machine specifications.

Windows

Right-click on the taskbar and select "Task Manager".
In the Task Manager window, go to the "Performance" tab.
Here you can see your CPU and GPU details. Click on "GPU" to see GPU information.
To see detailed GPU information including VRAM, click on "GPU 0" or your GPU's name.

Mac

Click on the Apple logo in the top-left corner of the screen.
Select "About This Mac".
In the window that opens, you can see if your machine runs an Intel chip or an Apple Silicon M-series chip.

Linux

Open a terminal window.
For CPU information, you can use the lscpu command.
For GPU information, you can use commands like lspci | grep -i vga to list GPU devices.

If you don’t have this installed, you may need to consult online forums for other options for your Linux machine.

Recommendations

If you’re interested in updating your machine to more efficiently run LLMs locally, you would generally want a GPU with a large amount of VRAM (Video Random Access Memory) to handle the memory-intensive operations involved in processing these models. GPUs with higher CUDA core counts and memory bandwidth can also contribute to faster computation.

In order to ensure your system can handle hefty local LLM hardware requirements, we recommend you double check the available RAM and VRAM based on these specifications:

Llama2 7B, a model trained by Meta AI optimized for completing general tasks.
Requires a minimum of 5.6GB RAM for the CPU model and 5.6GB of VRAM for the GPU-accelerated model.
Mistral 7B, a dense Transformer, fast-deployed and fine-tuned on code datasets. Small, yet powerful for a variety of use cases.
Requires a minimum of 6GB RAM for the CPU model and 6GB of VRAM for the GPU-accelerated model.
Phi-2 2.7B, a small language model that demonstrates outstanding reasoning and language understanding capabilities.
Requires a minimum of 3.1GB RAM for the CPU model and 3.1GB of VRAM for the GPU-accelerated model.

Note that as we continue supporting larger LLLMs like 13B models from Llama 2, these local LLM hardware requirements will change.

Performance and Troubleshooting

Deciding Which Local Model To Use

In a previous article, we discussed the best LLMs for coding, whether that be cloud vs local LLMs. If you’ve decided you want to stick with a local model within Pieces for increased security and offline capabilities, then you’ll want to first choose which one to use before downloading.

You will see that all of our local models have a CPU and GPU option. Now that you know a little more about your machine and GPU vs CPU, you can use the chart below to decide whether to use a GPU or a CPU version of a model.

Once you’ve decided on a GPU or CPU version, the choice between which brand model is more or less a matter of opinion, as models tend to excel in different types of knowledge (general QA, science, math, coding, etc.).

We at Pieces like to use a variety of models, to see the differences between answers we get based on the model’s knowledge base and training, and for different purposes - for example, the Pieces team member writing this article likes Phi-2 for its lightweight speed, but Mistral for its quality of answers. We’ve included some links to model evaluations below, but there is new information being released almost daily at this time.

Troubleshooting Common Issues

Encountering crashes or performance issues can often be attributed to exceeding your machine's resource capabilities. Checking your system specifications and comparing them against the requirements of your chosen LLM model is a good first step (we outlined how earlier in this article).

Another common issue on Linux and Windows is a corrupted or outdated Vulkan API, which we use to communicate with your GPU. Vulkan should be bundled with your AMD or NVIDIA drivers, and you can check its health by executing the command vulkaninfo in your terminal and scanning the resulting logs for errors or warnings. This could indicate that either your GPU drivers need updated or there is an issue with the API itself. Please contact the Pieces support team if you believe your Vulkan installation is broken.

Future-Proofing Your Setup

As technology advances, so do the requirements for running sophisticated models like LLMs. Upgrading to a system with a high-performance GPU and ample RAM can ensure your setup remains capable of handling new and more demanding large language models run locally. Additionally, staying informed about emerging trends in hardware can help you make knowledgeable decisions about future upgrades.

While we aimed to make this a complete guide to running local LLM models, things are evolving quickly and you may need to reference current research in order to understand how to run LLM models locally based on your hardware and memory requirements.

Join the Discussion

We hope this guide has shed some light on how to run an LLM locally efficiently and effectively within Pieces. We encourage our users to join the discussion on GitHub, share their experiences, and provide feedback. Your input is invaluable as we continue to refine our support for running LLMs locally, ensuring a seamless and productive experience for all our users.

If you’re just getting started with Large Language Models (LLMs), check out our whitepaper in the corresponding link.

Best AI Tools for Students Learning Development and Engineering

Pieces 🌟 — Mon, 18 Mar 2024 16:05:20 +0000

Our world is rapidly changing, and AI is a big part of that change. Students in development and engineering (and developers already in their careers) need to become proficient in AI tools. Perhaps not experts, but at least enough to understand how AI might or might not apply to a project.

These best AI tools for students can enhance your learning process and productivity, either in school or on the job. The first section describes each tool, and the second section describes how they could fit together into a streamlined workflow. The third section discusses the factors that affect your choice of AI tools.

10 Useful AI Tools for Students (and Developer Advancement)

These ten free AI tools for students are actually free for everyone. They provide a solid foundation to work on a wide range of artificial intelligence (AI) and machine learning projects. By exploring these tools and their documentation, you can gain hands-on experience, develop your skills, and tackle real-world challenges. They are the best AI tools for students and for developers who want to open new job opportunities or prepare for coding interviews.

The AI tools used by students, such as toolkits, notebooks, libraries, and frameworks, are the same tools used by developers in their careers. Each of the top AI tools for students plays a different but complementary role in software development. Their meanings sometimes overlap, and the specific roles may vary depending on the context and technology used.

Imagine you are an architect designing houses in a new subdivision. Frameworks are the pre-defined models, like a bungalow or a two-story, that provide a basic structure and guide your planning. You use a notebook to create your blueprints and sketches, where you experiment and plan the house.

There are two types of components you can use. Toolkits provide prefabricated components such as walls, doors, and windows. They speed up construction, but they may limit design freedom. In contrast, Libraries provide individual building blocks like bricks, pipes, and electrical components. You can use them independently or combine them into larger components.

Which label applies to a tool sometimes depends on what you do with it. For example, PyTorch or TensorFlow can be called a library, a toolkit, or a machine-learning framework.

Jupyter Notebook: Jupyter Notebook allows you to create documents called notebooks that combine code, text, and visualizations in a single interface. It supports multiple programming languages, including Python, R, and Julia. Jupyter Notebook is widely used in data analysis and exploration, machine-learning prototyping, and educational settings. It promotes reproducibility by capturing code, its output, and your textual explanations in a single file that can be shared with others.
TensorFlow: TensorFlow is an open-source machine-learning framework developed by Google. It provides a wide range of tools and libraries for building, training, and deploying various types of machine learning models, with a focus on deep learning. TensorFlow offers both high-level and low-level APIs, allowing users to choose between ease of use and flexibility. It supports distributed computing, enabling efficient training on multiple machines or GPUs.
PyTorch: PyTorch is an open-source machine-learning framework primarily developed by Facebook’s AI Research lab. It is known for its dynamic computational graph, which provides flexibility in model development and debugging. PyTorch has gained popularity in the research community due to its simplicity, strong support for neural network architectures, and its ability to seamlessly integrate with Python libraries.
Scikit-learn: Scikit-learn is a Python library that provides a robust set of tools for machine learning and data mining. It offers a wide variety of AI algorithms for classification, regression, clustering, and dimensionality reduction, along with utilities for data preprocessing and evaluation. Scikit-learn is designed with a consistent API, making it easy to experiment with different models and compare their performance.
Git: Git is a storage and distributed version control system that tracks changes to files and directories over time. It allows multiple developers to collaborate on a project, merging their changes efficiently. Git provides features such as branching and merging, which enable developers to work on separate features or experiment with code without affecting the main codebase. Platforms like GitHub and GitLab host Git repositories and provide additional features like issue tracking and pull requests.
Docker: Docker is an open-source containerization platform that allows you to package applications and their dependencies into lightweight, isolated containers. Containers provide a consistent and reproducible environment, ensuring that your code runs the same way across different systems. Docker allows you to define the dependencies and configurations of your application in a Dockerfile, making it easy to share and deploy your code on different machines or in the cloud.
OpenAI Gym: OpenAI Gym is a popular toolkit for developing and benchmarking reinforcement-learning algorithms. It provides a collection of environments, ranging from simple text-based games to complex control and robotics tasks. OpenAI Gym offers a simple and unified API to interact with these environments, making it easier to develop and compare different reinforcement-learning algorithms. It also includes evaluation metrics and tools for visualizing agent performance.
Pieces for Developers: Pieces is an AI-powered software tool designed to assist developers throughout their workflow. Its AI copilot offers real-time suggestions and AI assistance, ranging from code generation and debugging to exploring different approaches and improving code quality. Its plugins for browsers, IDEs, Obsidian, and other software tools access the same desktop repository. Consequently, Pieces stays context-aware and persists your conversation across all contexts with integrated AI. Its suggestions include relevant code snippets, code refactoring, alternative approaches, identifying potential errors, and providing explanations for complex concepts. Even if Pieces was treated only as a closed-source or open-source AI chatbot for students to help write code, its ability to add context to your conversations and leverage many of the best LLMs for coding would be very helpful.
Gradio: Gradio provides a rapid-prototyping visual interface for building interactive web demos for machine learning models. It is easy to share demos with instructors and peers, fostering collaboration and knowledge sharing within the classroom or project teams to facilitate communication and instant feedback exchange.
Hugging Face: Hugging Face is a community-driven online platform with a large library of pre-trained transformers and powerful deep-learning models for natural language processing (NLP) tasks. Like the other tools in this list, its resources, such as NLP tools, datasets, and tutorials, are freely available for individual use. These include exploring NLP tasks such as text classification, sentiment analysis, summarizing information, and question answering.

Workflow for an Example Project

I asked the Gemini LLM to define a streamlined workflow that combined these best free AI tools for students. The suggested workflow includes Jupyter Notebook, PyTorch, TensorFlow, Git, Scikit-learn, Docker, OpenAI Gym, and Pieces for Developers. Gradio and Hugging Face could also be included.

Project Setup:

Version Control: Use Git to initialize a repository for your project. This allows you to track changes, collaborate with others, and revert to previous versions if needed.
Environment Management: Consider using Docker to create isolated environments for your project. This ensures consistent dependencies and avoids conflicts across different machines. Define Dockerfiles specifying the necessary libraries (PyTorch, TensorFlow, Scikit-learn, OpenAI Gym) and their versions.
Experimentation & Documentation: Use Jupyter Notebook with the Pieces plugin as your primary development environment. It allows you to write, execute, and visualize both written and AI generated code interactively, and keep track of your results in a clear and organized manner. You can use it to explore ideas and document your work with rich markdown cells. For example, you can rapidly test and prototype functionalities with TensorFlow or PyTorch. You can visualize and analyze data generated by your agent’s interactions with the Gym environment. It also puts the full power of Pieces at your command as your personal coding assistant.

Development Workflow:

Data Preprocessing & Analysis: Use Scikit-learn for data preprocessing tasks like cleaning, scaling, and feature engineering. You can also use it for exploratory data analysis and model evaluation.
Model Development & Training: Import and use these libraries within your Jupyter Notebook cells to define your model architecture, train it on Gym data, and evaluate its performance. Both offer flexible and powerful tools for neural network creation and optimization. As the core libraries for building your reinforcement learning model, PyTorch might be preferred for its dynamic computational graph and ease of use, while TensorFlow offers scalability and production-ready AI features. If your project involves reinforcement learning, leverage OpenAI Gym to create and interact with simulated environments. It provides various environments for testing and training your reinforcement learning agents.
Version Control & Collaboration: After making changes in your notebook or code, commit them to your Git repository regularly. This allows you to track progress, revert to previous versions, and collaborate with others. The information is also saved in Pieces, which keeps a historical track of your workflow for going back in the past. Pieces can suggest who to ask questions about the code they provided.
Continuous Integration & Deployment: Consider setting up continuous integration and deployment pipelines to automate testing, building, and deployment of your project. This ensures consistency and streamlines the development process.

General Tips:

Start small and modular: Break down your project into smaller, manageable tasks and modules. This makes the development process more manageable and easier to debug. You can ask Pieces to troubleshoot your code and debug it for you.
Utilize community resources: Take advantage of online communities, forums, and tutorials for each tool and library. They offer valuable support and online learning opportunities. Pieces is open to questions in your IDE (such as Jupyter), your browser, and on the desktop so you can get answers and ask it about research while you continue coding, providing workflow integration across your entire toolchain.
Document your work: Use Jupyter notebooks to document your thought processes, code snippets, and results. This will be helpful for you and your collaborators in the future. You can use Pieces’ on-device AI to document your code and add your annotations to its enrichment of the code with its automatic explanations.
Test and iterate: Regularly test your code and models to identify and fix issues early on. Be prepared to iterate and adapt your approach based on your findings. Pieces records your workflow and can provide the materials you had been using that relate to the code.

Remember, this is just a general guideline, and the specific way you combine these tools will depend on your project’s unique requirements and goals.

Factors to Consider when Choosing

Choosing the right AI tools for student use depends on several factors. Here are some key considerations to keep in mind when selecting student AI tools for your projects:

Project Requirements: Consider the specific requirements of your project. What are you trying to accomplish? Are you working on a machine-learning task, data analysis, natural language processing, or computer vision? Different AI tools for students specialize in different areas, so choose the ones that align with your project goals.
Learning Curve and Documentation: Evaluate the learning curve associated with each tool. Consider how easy it is to get started and whether there are comprehensive documentation and tutorials available. Beginner-friendly tools with extensive community support can help you quickly grasp the concepts and start implementing your ideas.
Programming Language: Consider the programming language you are comfortable with or wish to learn. Many AI tools for students are available in Python, which is widely used in the AI community. However, there are also tools available in other languages such as R, Julia, or C++. Choose tools that are compatible with your preferred programming language or those that align with your academic program's requirements when learning new languages.
Community and Support: Assess the size and activity of the community surrounding the AI tools. Larger communities tend to offer more resources, tutorials, and active forums for seeking help and guidance. Robust community support can be invaluable, especially when you encounter challenges or have specific questions.
Integration and Compatibility: Consider how well the AI tools integrate with other libraries and frameworks you may want to use. For example, if you are working with data analysis, check if the tool integrates well with NumPy, Pandas, or SciPy. Compatibility with other tools ensures smooth workflow and enables you to leverage the strengths of multiple libraries.
Scalability and Performance: If you anticipate working on large-scale or computationally intensive projects, evaluate the scalability and performance of the AI-powered tool. Some frameworks offer distributed computing capabilities or support for GPUs, which can significantly speed up training and inference processes.
Industry Relevance: Consider the relevance of AI capabilities in industry applications and job market demand. Tools that are widely adopted in industry settings can provide you with valuable skills and enhance student employability. Staying updated with popular tools can also give you insights into current trends and advancements in the field.
Personal Interest and Future Goals: Lastly, consider your personal interests and long-term goals. Explore future AI tools that align with your interests and career aspirations. If you have a specific area of AI you wish to specialize in, choose tools that are commonly used in that domain to gain relevant expertise.

Considering these factors helps you make informed decisions about which emerging AI technologies to explore. However, only experimentation and hands-on experience with different tools will ultimately help you determine which of the different AI tools for students work best for you.

Conclusion

Other tools could have been included as the best AI tools for engineering students or students who write code for any reason. I focused on Python as the common programming language, but you can input code into Pieces and have it translated into any of the 40+ languages it supports.

Pieces’ ability to translate between languages is one of the main reasons I consider it the best free AI tool for students. Your lesson plans may have different requirements and may use different programming languages. Pieces is your personal intelligent tutor who can move between different languages and explain the code in ways the professor or the textbook didn't tell you, saving you time and making you more efficient.

It's worth noting that while these AI for college students may have prerequisites for learning, they also provide extensive documentation, tutorials, and resources to help beginners get started and learn the necessary concepts.

These resources provide a solid foundation for beginners to understand and apply neural networks and deep learning concepts. They offer a mix of theoretical explanations, practical examples, and hands-on programming exercises to help you gain a deeper understanding of the subject.

Exploring these resources will give you a strong starting point for your learning about AI tools. You can also reference our tips for software engineering students, and explore how Kyle Goben uses Pieces in our University Student User Story.

How to Use AI for Mobile App Development

Pieces 🌟 — Wed, 13 Mar 2024 16:53:31 +0000

Mobile developers are the creative minds and technical wizards behind the applications we use daily on our smartphones and tablets. In other words, they translate ideas into the mobile apps that control how we communicate, shop, play games, and access information on the go. Pieces, which is free to individuals, is the easy way for developers to use AI in mobile app development.

Four Ecosystems for AI Mobile App Development

As mobile technology continues to evolve, the knowledge and skills required for mobile app development AI continue to change. The immediate effect of AI’s rapid rise in popularity is the expectation that its full functionality will be available as an AI tool to create mobile apps. Emerging trends like augmented reality, virtual reality, and foldable devices require developers to change and push the boundaries of their AI tools for mobile app design.

Even the definition of a “mobile app developer” depends on the project. A mobile developer may be either front-end or full-stack for Android, iOS, or cross-platform with one codebase for both. There are also mobile game developers with different stacks who write C# or C++ for game engines.

There are four mobile app ecosystems with different frameworks, rules, guidelines, libraries, and other tools. Pieces can assist as an AI to create mobile apps in any of these through its browser and desktop modules.

A developer of native Android apps will probably use Android Studio and write code in Kotlin or Java.
An iOS native-app developer will probably use Xcode and write in Swift or Objective-C.
A developer who wants to maintain consistency with .Net will probably use Xamarin and write in C#.
The tools a developer writing for Web open-source would use are less clearly defined. For example, the developer might use Qt (“cute”) software, but the limited market share and lack of dedicated development tools and resources compared to Android and iOS make it less popular than other frameworks.

Choosing the Right Framework

A cross-platform developer may use React Native, Flutter, Electron, Xamarin, or other frameworks (learn the difference between Flutter vs React Native, and Flutter vs Electron). The five major frameworks (or Native IDEs) listed in the following table vary in several ways, including how much they are like native code. The most important factors in choosing a framework (or multiple frameworks) are discussed after the table.

There are three very important considerations when choosing a framework or native IDE for mobile app development with AI:

Consider your target platform: If you specifically need to target only Android or iOS, using the native framework (Kotlin/Java for Android, Swift for iOS) might be the preferred approach for optimal performance and access to native functionalities.
Evaluate your team's skills: If your team is already comfortable with JavaScript and React, React Native could be a good choice. If you prefer a single codebase for both platforms and are open to learning Dart, Flutter could be a viable option (see how Pieces used Dart and Flutter to build their cross-platform application). If your team has experience with .NET languages, Xamarin (or Microsoft’s replacement for it) might be a strong contender.
Project requirements: If your app requires specific functionalities or needs deep integration with native features, using the native framework might be necessary. For simpler apps, a cross-platform framework could be a more efficient choice.

It's important to research each framework in detail, consider your specific needs and constraints, and explore the resources and communities available for each option before making a decision. Remember, there's no "one size fits all" answer, and the best framework for your mobile app project depends on various factors.

Where Pieces Is Especially Useful

The more variations in the types of code snippets used by a developer, the more Pieces for Developers can streamline the workflow. This especially includes moving between frameworks for different projects. You can relaunch onboarding in Pieces at any time to change your persona(s) and languages. This, along with storing various code snippets from your workflow, regrounds the AI into the languages and materials of your workflow.

There are four major stages in a developer’s mobile app workflow:

Collaborative Design

This involves understanding user needs, translating them into app features and functionalities, and creating user interfaces (UI) that are intuitive and visually appealing. This often requires working closely with designers, product managers, and other stakeholders to understand the purpose, target audience, and desired features of the app. It also includes ensuring maintainability.

Pieces’ advanced features, such as workflow history, support easy communication and code collaboration. For example, if the code for a widget comes from someone, then the source, perhaps even the person's name, is associated with that widget’s code in the developer’s workflow. That information can be retrieved months later to ask a question.

Development

Choosing the appropriate programming languages and frameworks to write the code. This involves building the user interface (UI) for the interactions, writing the back-end logic for functionality, and integrating various features like databases, APIs, and security measures.

Pieces provides all the traditionally expected features of a copilot and more. It can easily translate code in a language for one framework into a different language for a different framework, such as described in this mobile app development user story. It supports 40+ languages. It also can keep track of different versions of the same functional snippet in different languages, used in different UI versions, or for different projects.

Testing and Debugging

Testing the app on various devices and operating systems to ensure it functions as intended, identifying and fixing any bugs or performance issues.

Pieces can troubleshoot code and debug it. It also can write unit tests, and even enhance AI code review efficiency.

Deployment and Maintenance

Deploying the app to app stores like Google Play Store or Apple App Store, and continuing to monitor its performance, address user feedback, and release updates with new features or bug fixes.

Pieces’ snippet enrichments and the developer’s annotations can be retrieved for any code written by the developer in the past. If a new developer is onboarded to the same repository after the previous developer leaves, the new developer has access to the stored workflow to ask the AI questions and get intelligent answers about the code.

Also, Pieces provides different views for looking at code. The list view shows more auto-enrichment data and is great for shorter snippets. In contrast, the gallery view is more for longer snippets, and it is easy to move left and right between them.

There is another view in Pieces called workflow activity. You can filter that and search through it to see anything that you've referenced or opened any code snippets that you've used. This also works with the extensions as well. You can review any snippet that you saved when you did it. Later, you can go back through your workflow and remember how you did something.

Pieces Mobile Use Case Interview

Dan O’Leary, an avid Pieces user, was working on an iOS application for tracking aviation fuel at the time of the interview. It is now his fourth app in the Apple store. His full-time job is being a pilot, so he requires that any tool in his stack makes him more productive. He switches among frameworks depending on the mobile app project.

The iOS app development user story he discussed in the interview is a recurring theme across his apps: “I seem to always find myself working with dates, date comparisons, whether I want to or not. I have another app on the store that's a running app. And so then that's not really dates, but it's more timers. Date comparisons and working with time is strangely complicated.”

Before using Pieces, Dan used Snippets Lab for Mac. He said, “It was about half of the functionality or maybe a quarter of the functionality” of Pieces. His repository was “blocks of code that helped me sort dates—or things that I like to use to deal with sorting and comparing time. And so, you know, these are either live in a project or they live in a file that I can reference back because once I switch frameworks or I work on a different project, I'll forget again how to do that.

Then I go back to falling into the trap of working with dates again–-I've forgotten. So I need to go back and open up my toolbox and look for what I need to do to remember how to do that. Because I don't. I don't work on only that all the time. And when you're context switching like that, it's too hard to just memorize everything. I don't think it's reasonable to expect a developer to do that.

So having some sort of a tool in your workflow that you can search, which is great with your app that's got this automatic tagging for the frameworks and what the code actually does. Super handy for me. It just speeds up what I'm looking for and knowing what I have–-because maybe I don't have a block of code that does that. I won't waste my time looking for something that I don't have.”

What Else the User Said

Conversational Interface: “I played around with the copilot and I love that very familiar ChatGPT style. You know, kind of ask a question and I really like that it actually gave me an answer on how I was working on something. It spit out an answer that I needed, so that is very cool.”
Searchable tags: “I can't think of any other platform I've used that I've had my searchable tags for my code. … The fact that it auto-generates this stuff is, to me, that blew me away.”
Security and Privacy: “[I]t's so cool that it’s on-device … for people working in a security-sensitive or intellectual-property kind of environment, ... it's like, oh, that's very cool that you can't just send your code out to the world for storage or reference or anything.” Some people save API keys because they reuse them and Pieces will be able to identify sensitive information. The actual key will get flagged before you try to share it with someone or use it in your IDE. You'll get a little warning pop-up.

Conclusion

Each of the mobile-device ecosystems includes many different devices with different screen sizes, pixel densities, and OS versions. The complexity these differences add to development, testing, and maintenance is a strong justification for including Pieces as a tool for workflow integration with AI. Its intelligent management of snippets identifies and organizes which snippets are relevant to what devices and when and where they were used.

The following quote from a user confirms the statements made in this post. Pieces’ advanced features gives it a special position among the numerous AI tools for mobile app development.

“Pieces is the most useful piece of AI, machine learning, you know, whatever you want to call it, to me so far… because one thing in researching AI, as I've been doing the last few months, is I want to use this to make my work more efficient, … I guess my answer is, what I've seen you guys do is the best integration to my daily life that I have yet to see from any sort of machine learning and artificial intelligence [tool]—to my software development life.”

Navigating the Future with AI Copilots: A Comprehensive Guide

Pieces 🌟 — Wed, 13 Mar 2024 16:00:31 +0000

AI copilots are popping up everywhere, changing how we work. They do the boring stuff so we can focus on the big ideas.

For an overworked developer, they are a long-awaited miracle. Work's got too much going on. Too many emails, too much data, too little time. It's tough to keep up. You're stuck doing tasks that feel like a waste of your skills.

Having an AI copilot to handle the repetitive tasks and help make better decisions faster lets you get more done and have time for creative work. With the recent AI explosion, it is no surprise that there are a ton of options out there. So, in today’s guide, we’re going to explore a few of the best AI copilots and how to use them to their full potential.

Understanding AI Copilots

In simple terms, an AI copilot is a supportive tool that utilizes artificial intelligence to augment human capabilities. It doesn’t take away your entire workload but rather helps you focus on things besides hammering out lines of code.

The technology behind AI copilots is both fascinating and complex. At the core of most copilots is a suite of machine learning algorithms and models that enable them to process and understand large datasets. These models, particularly Large Language Models (LLMs), are trained on a wide array of data sources to recognize patterns, predict outcomes, and generate human-like responses.

The impact of AI copilots is far-reaching, with a presence in sectors such as software development, healthcare, finance, and customer service. With companies like OpenAI, Google, and Microsoft all racing to develop the best possible solutions, we can enjoy the benefits of this rapidly improving technology for a wide range of use cases.

Benefits of Using AI Copilots

The benefits of using an AI coding copilot are substantial, particularly when it comes to software development. There are a lot of areas in coding that take up valuable time. Things like typing out boilerplate, templates, and frequently used code blocks — all take away from the part of software development that requires us to use our brains. A good copilot AI tool can help out in all of these areas.

Increased Developer Productivity

One of the primary benefits of an AI-powered copilot is their ability to significantly boost efficiency and productivity.

Enhanced Accuracy and Decision-making

Another key advantage is the enhancement of accuracy and decision-making. AI copilots are capable of suggesting entire blocks of code and solutions to problems that may arise, which can help reduce errors and improve the quality of the final product.

Customization and Learning from User Interactions

A modern copilot AI tool is designed to learn from user interactions and adapt over time, offering personalized support that becomes more accurate and helpful with each use. For the longest time, LLMs were only good at making semi-usable suggestions. But with the increased innovation, evidenced by recent ChatGPT claims to remember user conversations, we can offload some of our brain-power to an AI coding assistant copilot.

Reduction in Repetitive Task Load

As developers, typing the same code over and over again can take the wind out of our sails. Besides making the job boring, having to do repetitive tasks drains our energy away from more important areas like creativity and strategic thinking. Copilot AI coding allows for the reduction in this repetitive task load, and tools like Pieces can even help you store code snippets you frequently reuse so you don’t have to go back and look for that perfect snippet you researched a month ago.

AI copilots take on the burden of mundane tasks, freeing up developers to focus on more complex, creative, and strategic aspects of their projects. This shift in focus can lead to more innovative solutions and advancements in the field.

Best AI Copilots on the Market

Pieces

Pieces is one of the more powerful AI copilots out there that enhances developer productivity by offering personalized workflow assistance. It's particularly good at capturing and enriching materials, streamlining collaboration, and solving complex problems through a thorough understanding of your unique workflow.

The great thing about Pieces is that it operates at the system level, integrating your workflow across the browser, IDE and collaboration software through retrieval augmented generation, which allows it to make highly contextual suggestions based on the things you're referencing and interacting with. It's available on macOS, Windows, and even Linux.

Pieces is a huge leg up for anyone looking to increase developer productivity on their team. But besides easing developer fatigue, security is also a major advantage. Unlike strictly cloud-based solutions, data security is a top priority with Pieces. Your information stays on your machine, and all large and small language models run on-device, ensuring that your work remains private and secure. And for those times when offline AI isn't an option, cloud capabilities are available as an opt-in feature.

There are more than a handful of ways to implement Pieces. You can find an extension or plugin for everything from IDEs like VS Code and JetBrains to knowledge management apps like Obsidian. Just locate the Pieces extension or plugin you need from the website, install it, and follow any onboarding instructions provided. The process is designed to be user-friendly, often requiring only a few clicks to get started.

Github Copilot

If you’ve been working in software development for any length of time, you have likely heard of this one. GitHub Copilot is powered by OpenAI's Codex, a descendant of the GPT-3 family, but fine-tuned specifically for code completion. It works by analyzing the vast repositories of code available on GitHub to learn coding patterns, styles, and best practices, such as comments, function names, and the code itself, to generate syntactically correct and logically fitting code suggestions.

Like Pieces, GitHub Copilot prides itself on easing the dreaded developer burnout that comes with spending hours on mundane code-monkey tasks. According to GitHub, developers who use Copilot find that it helps them code faster and more efficiently. For instance, in a survey conducted by GitHub, it was found that developers who use Copilot can write code up to 55% faster, reducing the time spent searching for code snippets and solutions online.

Learn what the best free and paid GitHub Copilot alternatives are in our latest post.

Microsoft Copilot

Given how much Microsoft has reshaped technology over the past few decades, it’s honestly surprising that we didn’t get a copilot AI assistant from them sooner. But now that it’s finally here, it does not disappoint.

Microsoft Copilot is part of a broader vision to embed AI into the fabric of software development and beyond. While GitHub Copilot focuses specifically on code suggestions, Microsoft's Copilot aims to be a comprehensive assistant across various Microsoft products and services, including development tools.

CodeWP

This one is a little different from the others in that it is targeted at a niche developer audience: WordPress developers. There are plenty of broad generative AI copilots out there, so having one tailored to a specific tech stack can come in handy. Since WordPress powers 43.1% of all websites, this specialized AI assistant is still useful to a broad audience.

CodeWP can help you with all sorts of WordPress tasks such as generating PHP, JavaScript, and CSS code based on natural language descriptions. For WordPress developers, this means less time googling code snippets and more time focusing on creating custom, high-quality themes and plugins.

SQL.ai

Database programming languages are a completely different beast compared to things like JavaScript, Ruby, or Python. But the fact is that almost every developer needs to work with a database at some point, even if it isn’t fun. Having an AI-powered copilot to help you out can be a massive timesaver.

SQLAI.ai focuses entirely on generating SQL queries for you. Unless you’re a SQL developer with a passion for the language who enjoys every second of typing out the perfect query, you’ll love this one.

There are a few capabilities that this AI code copilot helps out with. The first is that you can type out what you want your SQL queries to do using everyday language. Compared to looking up syntax and making sure you’re doing everything right according to the documentation, this is much faster. You can also optimize or fix your SQL using AI. Paste your query into the box and watch the AI copilot work its magic in a few seconds.

You won’t find a vast extension marketplace like some of the other AI copilots, but the pricing and ease of use can’t be argued with. You can pick plans from $4 per month, or even less if you pay by the year. Another drawback is that this is primarily an AI copilot for the web. So, you won’t be able to download it or use it within your IDE.

How to Choose the Right AI Copilot for Your Needs

When it comes to choosing an AI copilot, the decision boils down to understanding your needs, the unique offerings of each AI copilot, and how they align with your development goals. Here’s how you should approach this selection process.

Consider your industry focus and project requirements. If you need something for a specific use case such as WordPress or SQL, then you could consider CodeWP or SQL.ai. On the other hand, if you need a more versatile solution, consider something like Pieces for Developers or GitHub Copilot.
Evaluate the ease of integration and compatibility. If you want to stick to your favorite IDE or software interface, make sure you pick an AI copilot for the web, editor, and other tools, not just one for a specific app.
Project complexity and tech stack. If your project is simple and limited to one app, such as WordPress, then you might be fine with a more limited AI copilot like CodeWP. Conversely, if your project incorporates multiple programming languages and apps, you might want to consider something with more diverse capabilities.
Core functionality. Many AI assistants have very basic functionality, like SQL.ai, and they can only do one or two things at a time. Others, such as Microsoft Copilot, can handle a wide range of tasks across your entire operating system.
Developer support. You’ll want to make sure you pick an AI coding assistant that has extensive documentation and a library of tutorials to help you get started.
Cost-effectiveness. Many generative AI copilots are free, such as Pieces. But other AI copilots charge a monthly subscription, like GitHub Copilot. Think about your budget when deciding which one is best for you.

Implementing AI Copilots in Your Workflow

Integrating an AI assistant copilot into your daily tasks can significantly boost your team's productivity and streamline operations. Here is a quick step-by-step for integrating an AI-powered copilot into your workflow:

Identify opportunities. Look at your daily operations to find areas where an AI copilot can make a difference. This could be anything from data entry and scheduling to more complex problem-solving tasks.
Select the right tool. Not all AI copilots are created equal. Choose one that fits well with your team's needs and the specific tasks you want to automate.
Start small. Begin with a pilot program. Implement the AI copilot in a small, controlled environment to gauge its effectiveness and identify any adjustments needed.
Educate your team. Make sure your team knows how to work with the AI. This might include training sessions or workshops to get everyone up to speed.
Evaluate and scale. Continuously assess the AI copilot’s impact on your workflow. If it proves beneficial, consider expanding its role within your organization.

What about Enterprise AI Copilots?

It seems every company out there is adding AI to their toolbox in some way or another. And this is all for a very good reason. AI is a game-changer when it comes to addressing the rapid pace of technological change and the growing complexity of software development.

Enterprises face challenges such as high developer turnover and the need for faster onboarding and upskilling of new team members. AI copilots can help with these challenges by offering real-time assistance, automating routine tasks, and enabling more efficient knowledge transfer and collaboration among team members.

As developers, we’re often told to consult the docs when we have a problem. But how often is documentation far more long and convoluted than it needs to be? It isn’t the best part of anyone’s day when we have to sift through pages of unfamiliar documents just to find the solution to a niche issue or bug. A good copilot AI tool can be a huge help here and reduce the cognitive load on developers, helping them to focus on more creative and strategic aspects of their work.

Becoming an AI-powered enterprise isn’t all that difficult either, and the leap is often more than worth it.

How to Build an AI Copilot

Building your own free AI copilot is a great way to both learn about the underlying tech and customize it to your heart’s content. We’ll give you a quick rundown of how to do this with Pieces. Start with understanding the Pieces OS Client, which is essentially the heart of your custom copilot. It's a database that comes with the advantage of built-in LLMs and the ability to set custom context for your conversations.

When you're setting up, you'll want to choose an SDK that fits your language preference. Pieces has made it rather convenient by offering a variety of SDKs including Typescript, Python, Kotlin, and Dart. This means you can work in a language you're comfortable with and still leverage the powerful features of Pieces OS.

Once you've downloaded the desired SDK, such as the Typescript SDK, and installed Pieces OS on your machine, you're ready to start crafting your copilot. The beauty of this setup is that you can start making requests to your copilot with minimal setup, which is great for getting up and running quickly.

Depending on your requirements, you can manage and use various cloud-based and local LLMs. Download them locally with the help of modelsProgressController.tsx for offline use, or connect to cloud-based models if you prefer.

If you want, you can enhance your copilot’s responses by adding context to your queries. Unlike many environments where you might have to retrain models with your data to get relevant answers, Pieces allows you to attach context to your questions, so you can get more accurate and tailored responses without the wait.

You can check out our in-depth guide on building your own copilot AI here.

The Future of AI Copilots

Industry leaders at Andreessen Horowitz say the era we're entering could be akin to a new Industrial Revolution for cognitive tasks, suggesting a significant boost in productivity for knowledge workers. AI copilots serve as early examples of how AI can make knowledge work more efficient and enjoyable, pointing towards a future where the collaboration between humans and AI leads to unprecedented levels of productivity and innovation.

Pieces is at the forefront of this revolution, directly enhancing the efficiency and productivity of developers by integrating AI-powered solutions into their workflows. The ability to create personalized suggestions and automate parts of the coding process, grounded in the unique context of each developer's work, embodies the promise of AI copilots in transforming cognitive tasks.

All of this technology was a pipedream just a few years ago. But now it is a reality. If you want to see how, just download Pieces and try it out for yourself.